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
60244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_get() {
60245   int jresult ;
60246   int result;
60247   {
60248     try
60249     {
60250       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60251     } catch (std::out_of_range& e) {
60252       {
60253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60254       };
60255     } catch (std::exception& e) {
60256       {
60257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60258       };
60259     } catch (...) {
60260       {
60261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60262       };
60263     }
60264   }
60265   jresult = (int)result;
60266   return jresult;
60267 }
60268
60269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60270   int jresult ;
60271   int result;
60272   {
60273     try
60274     {
60275       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60276     } catch (std::out_of_range& e) {
60277       {
60278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60279       };
60280     } catch (std::exception& e) {
60281       {
60282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60283       };
60284     } catch (...) {
60285       {
60286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60287       };
60288     }
60289   }
60290   jresult = (int)result;
60291   return jresult;
60292 }
60293
60294
60295
60296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60297   int jresult ;
60298   int result;
60299
60300   {
60301     try {
60302       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60303     } catch (std::out_of_range& e) {
60304       {
60305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60306       };
60307     } catch (std::exception& e) {
60308       {
60309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60310       };
60311     } catch (Dali::DaliException e) {
60312       {
60313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60314       };
60315     } catch (...) {
60316       {
60317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60318       };
60319     }
60320   }
60321
60322   jresult = (int)result;
60323   return jresult;
60324 }
60325
60326
60327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60328   int jresult ;
60329   int result;
60330
60331   {
60332     try {
60333       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60334     } catch (std::out_of_range& e) {
60335       {
60336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60337       };
60338     } catch (std::exception& e) {
60339       {
60340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60341       };
60342     } catch (Dali::DaliException e) {
60343       {
60344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60345       };
60346     } catch (...) {
60347       {
60348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60349       };
60350     }
60351   }
60352
60353   jresult = (int)result;
60354   return jresult;
60355 }
60356
60357
60358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60359   int jresult ;
60360   int result;
60361
60362   {
60363     try {
60364       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60365     } catch (std::out_of_range& e) {
60366       {
60367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60368       };
60369     } catch (std::exception& e) {
60370       {
60371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60372       };
60373     } catch (Dali::DaliException e) {
60374       {
60375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60376       };
60377     } catch (...) {
60378       {
60379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60380       };
60381     }
60382   }
60383
60384   jresult = (int)result;
60385   return jresult;
60386 }
60387
60388
60389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60390   int jresult ;
60391   int result;
60392
60393   {
60394     try {
60395       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60396     } catch (std::out_of_range& e) {
60397       {
60398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60399       };
60400     } catch (std::exception& e) {
60401       {
60402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60403       };
60404     } catch (Dali::DaliException e) {
60405       {
60406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60407       };
60408     } catch (...) {
60409       {
60410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60411       };
60412     }
60413   }
60414
60415   jresult = (int)result;
60416   return jresult;
60417 }
60418
60419
60420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60421   int jresult ;
60422   int result;
60423
60424   {
60425     try {
60426       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60427     } catch (std::out_of_range& e) {
60428       {
60429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60430       };
60431     } catch (std::exception& e) {
60432       {
60433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60434       };
60435     } catch (Dali::DaliException e) {
60436       {
60437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60438       };
60439     } catch (...) {
60440       {
60441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60442       };
60443     }
60444   }
60445
60446   jresult = (int)result;
60447   return jresult;
60448 }
60449
60450
60451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60452   int jresult ;
60453   int result;
60454
60455   {
60456     try {
60457       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60458     } catch (std::out_of_range& e) {
60459       {
60460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60461       };
60462     } catch (std::exception& e) {
60463       {
60464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60465       };
60466     } catch (Dali::DaliException e) {
60467       {
60468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60469       };
60470     } catch (...) {
60471       {
60472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60473       };
60474     }
60475   }
60476
60477   jresult = (int)result;
60478   return jresult;
60479 }
60480
60481
60482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60483   int jresult ;
60484   int result;
60485
60486   {
60487     try {
60488       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60489     } catch (std::out_of_range& e) {
60490       {
60491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60492       };
60493     } catch (std::exception& e) {
60494       {
60495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60496       };
60497     } catch (Dali::DaliException e) {
60498       {
60499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60500       };
60501     } catch (...) {
60502       {
60503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60504       };
60505     }
60506   }
60507
60508   jresult = (int)result;
60509   return jresult;
60510 }
60511
60512 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60513   int jresult ;
60514   int result;
60515
60516   {
60517     try {
60518       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60519     } catch (std::out_of_range& e) {
60520       {
60521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60522       };
60523     } catch (std::exception& e) {
60524       {
60525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60526       };
60527     } catch (...) {
60528       {
60529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60530       };
60531     }
60532   }
60533   jresult = (int)result;
60534   return jresult;
60535 }
60536
60537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60538   int jresult ;
60539   int result;
60540
60541   {
60542     try {
60543       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60544     } catch (std::out_of_range& e) {
60545       {
60546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60547       };
60548     } catch (std::exception& e) {
60549       {
60550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60551       };
60552     } catch (Dali::DaliException e) {
60553       {
60554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60555       };
60556     } catch (...) {
60557       {
60558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60559       };
60560     }
60561   }
60562
60563   jresult = (int)result;
60564   return jresult;
60565 }
60566
60567
60568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60569   int jresult ;
60570   int result;
60571
60572   {
60573     try {
60574       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60575     } catch (std::out_of_range& e) {
60576       {
60577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60578       };
60579     } catch (std::exception& e) {
60580       {
60581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60582       };
60583     } catch (Dali::DaliException e) {
60584       {
60585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60586       };
60587     } catch (...) {
60588       {
60589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60590       };
60591     }
60592   }
60593
60594   jresult = (int)result;
60595   return jresult;
60596 }
60597
60598
60599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60600   int jresult ;
60601   int result;
60602
60603   {
60604     try {
60605       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60606     } catch (std::out_of_range& e) {
60607       {
60608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60609       };
60610     } catch (std::exception& e) {
60611       {
60612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60613       };
60614     } catch (Dali::DaliException e) {
60615       {
60616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60617       };
60618     } catch (...) {
60619       {
60620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60621       };
60622     }
60623   }
60624
60625   jresult = (int)result;
60626   return jresult;
60627 }
60628
60629
60630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60631   int jresult ;
60632   int result;
60633
60634   {
60635     try {
60636       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60637     } catch (std::out_of_range& e) {
60638       {
60639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60640       };
60641     } catch (std::exception& e) {
60642       {
60643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60644       };
60645     } catch (Dali::DaliException e) {
60646       {
60647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60648       };
60649     } catch (...) {
60650       {
60651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60652       };
60653     }
60654   }
60655
60656   jresult = (int)result;
60657   return jresult;
60658 }
60659
60660
60661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60662   int jresult ;
60663   int result;
60664
60665   {
60666     try {
60667       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60668     } catch (std::out_of_range& e) {
60669       {
60670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60671       };
60672     } catch (std::exception& e) {
60673       {
60674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60675       };
60676     } catch (Dali::DaliException e) {
60677       {
60678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60679       };
60680     } catch (...) {
60681       {
60682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60683       };
60684     }
60685   }
60686
60687   jresult = (int)result;
60688   return jresult;
60689 }
60690
60691
60692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60693   int jresult ;
60694   int result;
60695
60696   {
60697     try {
60698       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60699     } catch (std::out_of_range& e) {
60700       {
60701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60702       };
60703     } catch (std::exception& e) {
60704       {
60705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60706       };
60707     } catch (Dali::DaliException e) {
60708       {
60709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60710       };
60711     } catch (...) {
60712       {
60713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60714       };
60715     }
60716   }
60717
60718   jresult = (int)result;
60719   return jresult;
60720 }
60721
60722
60723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60724   int jresult ;
60725   int result;
60726
60727   {
60728     try {
60729       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60730     } catch (std::out_of_range& e) {
60731       {
60732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60733       };
60734     } catch (std::exception& e) {
60735       {
60736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60737       };
60738     } catch (Dali::DaliException e) {
60739       {
60740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60741       };
60742     } catch (...) {
60743       {
60744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60745       };
60746     }
60747   }
60748
60749   jresult = (int)result;
60750   return jresult;
60751 }
60752
60753
60754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60755   int jresult ;
60756   int result;
60757
60758   {
60759     try {
60760       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60761     } catch (std::out_of_range& e) {
60762       {
60763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60764       };
60765     } catch (std::exception& e) {
60766       {
60767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60768       };
60769     } catch (Dali::DaliException e) {
60770       {
60771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60772       };
60773     } catch (...) {
60774       {
60775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60776       };
60777     }
60778   }
60779
60780   jresult = (int)result;
60781   return jresult;
60782 }
60783
60784
60785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60786   int jresult ;
60787   int result;
60788
60789   {
60790     try {
60791       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60792     } catch (std::out_of_range& e) {
60793       {
60794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60795       };
60796     } catch (std::exception& e) {
60797       {
60798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60799       };
60800     } catch (Dali::DaliException e) {
60801       {
60802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60803       };
60804     } catch (...) {
60805       {
60806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60807       };
60808     }
60809   }
60810
60811   jresult = (int)result;
60812   return jresult;
60813 }
60814
60815
60816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60817   int jresult ;
60818   int result;
60819
60820   {
60821     try {
60822       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60823     } catch (std::out_of_range& e) {
60824       {
60825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60826       };
60827     } catch (std::exception& e) {
60828       {
60829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60830       };
60831     } catch (Dali::DaliException e) {
60832       {
60833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60834       };
60835     } catch (...) {
60836       {
60837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60838       };
60839     }
60840   }
60841
60842   jresult = (int)result;
60843   return jresult;
60844 }
60845
60846
60847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60848   int jresult ;
60849   int result;
60850
60851   {
60852     try {
60853       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60854     } catch (std::out_of_range& e) {
60855       {
60856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60857       };
60858     } catch (std::exception& e) {
60859       {
60860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60861       };
60862     } catch (Dali::DaliException e) {
60863       {
60864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60865       };
60866     } catch (...) {
60867       {
60868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60869       };
60870     }
60871   }
60872
60873   jresult = (int)result;
60874   return jresult;
60875 }
60876
60877
60878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60879   int jresult ;
60880   int result;
60881
60882   {
60883     try {
60884       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60885     } catch (std::out_of_range& e) {
60886       {
60887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60888       };
60889     } catch (std::exception& e) {
60890       {
60891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60892       };
60893     } catch (Dali::DaliException e) {
60894       {
60895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60896       };
60897     } catch (...) {
60898       {
60899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60900       };
60901     }
60902   }
60903
60904   jresult = (int)result;
60905   return jresult;
60906 }
60907
60908
60909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60910   int jresult ;
60911   int result;
60912
60913   {
60914     try {
60915       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60916     } catch (std::out_of_range& e) {
60917       {
60918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60919       };
60920     } catch (std::exception& e) {
60921       {
60922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60923       };
60924     } catch (Dali::DaliException e) {
60925       {
60926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60927       };
60928     } catch (...) {
60929       {
60930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60931       };
60932     }
60933   }
60934
60935   jresult = (int)result;
60936   return jresult;
60937 }
60938
60939
60940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60941   int jresult ;
60942   int result;
60943
60944   {
60945     try {
60946       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60947     } catch (std::out_of_range& e) {
60948       {
60949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60950       };
60951     } catch (std::exception& e) {
60952       {
60953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60954       };
60955     } catch (Dali::DaliException e) {
60956       {
60957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60958       };
60959     } catch (...) {
60960       {
60961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60962       };
60963     }
60964   }
60965
60966   jresult = (int)result;
60967   return jresult;
60968 }
60969
60970
60971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60972   int jresult ;
60973   int result;
60974
60975   {
60976     try {
60977       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60978     } catch (std::out_of_range& e) {
60979       {
60980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60981       };
60982     } catch (std::exception& e) {
60983       {
60984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60985       };
60986     } catch (Dali::DaliException e) {
60987       {
60988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60989       };
60990     } catch (...) {
60991       {
60992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60993       };
60994     }
60995   }
60996
60997   jresult = (int)result;
60998   return jresult;
60999 }
61000
61001
61002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61003   int jresult ;
61004   int result;
61005
61006   {
61007     try {
61008       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61009     } catch (std::out_of_range& e) {
61010       {
61011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61012       };
61013     } catch (std::exception& e) {
61014       {
61015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61016       };
61017     } catch (Dali::DaliException e) {
61018       {
61019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61020       };
61021     } catch (...) {
61022       {
61023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61024       };
61025     }
61026   }
61027
61028   jresult = (int)result;
61029   return jresult;
61030 }
61031
61032
61033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61034   int jresult ;
61035   int result;
61036
61037   {
61038     try {
61039       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61040     } catch (std::out_of_range& e) {
61041       {
61042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61043       };
61044     } catch (std::exception& e) {
61045       {
61046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61047       };
61048     } catch (Dali::DaliException e) {
61049       {
61050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61051       };
61052     } catch (...) {
61053       {
61054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61055       };
61056     }
61057   }
61058
61059   jresult = (int)result;
61060   return jresult;
61061 }
61062
61063
61064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61065   int jresult ;
61066   int result;
61067
61068   {
61069     try {
61070       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61071     } catch (std::out_of_range& e) {
61072       {
61073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61074       };
61075     } catch (std::exception& e) {
61076       {
61077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61078       };
61079     } catch (Dali::DaliException e) {
61080       {
61081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61082       };
61083     } catch (...) {
61084       {
61085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61086       };
61087     }
61088   }
61089
61090   jresult = (int)result;
61091   return jresult;
61092 }
61093
61094
61095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61096   int jresult ;
61097   int result;
61098
61099   {
61100     try {
61101       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61102     } catch (std::out_of_range& e) {
61103       {
61104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61105       };
61106     } catch (std::exception& e) {
61107       {
61108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61109       };
61110     } catch (Dali::DaliException e) {
61111       {
61112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61113       };
61114     } catch (...) {
61115       {
61116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61117       };
61118     }
61119   }
61120
61121   jresult = (int)result;
61122   return jresult;
61123 }
61124
61125
61126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61127   int jresult ;
61128   int result;
61129
61130   {
61131     try {
61132       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61133     } catch (std::out_of_range& e) {
61134       {
61135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61136       };
61137     } catch (std::exception& e) {
61138       {
61139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61140       };
61141     } catch (Dali::DaliException e) {
61142       {
61143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61144       };
61145     } catch (...) {
61146       {
61147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61148       };
61149     }
61150   }
61151
61152   jresult = (int)result;
61153   return jresult;
61154 }
61155
61156
61157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61158   int jresult ;
61159   int result;
61160
61161   {
61162     try {
61163       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61164     } catch (std::out_of_range& e) {
61165       {
61166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61167       };
61168     } catch (std::exception& e) {
61169       {
61170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61171       };
61172     } catch (Dali::DaliException e) {
61173       {
61174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61175       };
61176     } catch (...) {
61177       {
61178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61179       };
61180     }
61181   }
61182
61183   jresult = (int)result;
61184   return jresult;
61185 }
61186
61187
61188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61189   int jresult ;
61190   int result;
61191
61192   {
61193     try {
61194       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61195     } catch (std::out_of_range& e) {
61196       {
61197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61198       };
61199     } catch (std::exception& e) {
61200       {
61201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61202       };
61203     } catch (Dali::DaliException e) {
61204       {
61205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61206       };
61207     } catch (...) {
61208       {
61209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61210       };
61211     }
61212   }
61213
61214   jresult = (int)result;
61215   return jresult;
61216 }
61217
61218
61219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61220   int jresult ;
61221   int result;
61222
61223   {
61224     try {
61225       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61226     } catch (std::out_of_range& e) {
61227       {
61228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61229       };
61230     } catch (std::exception& e) {
61231       {
61232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61233       };
61234     } catch (Dali::DaliException e) {
61235       {
61236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61237       };
61238     } catch (...) {
61239       {
61240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61241       };
61242     }
61243   }
61244
61245   jresult = (int)result;
61246   return jresult;
61247 }
61248
61249
61250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61251   int jresult ;
61252   int result;
61253
61254   {
61255     try {
61256       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61257     } catch (std::out_of_range& e) {
61258       {
61259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61260       };
61261     } catch (std::exception& e) {
61262       {
61263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61264       };
61265     } catch (Dali::DaliException e) {
61266       {
61267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61268       };
61269     } catch (...) {
61270       {
61271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61272       };
61273     }
61274   }
61275
61276   jresult = (int)result;
61277   return jresult;
61278 }
61279
61280
61281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61282   int jresult ;
61283   int result;
61284
61285   {
61286     try {
61287       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61288     } catch (std::out_of_range& e) {
61289       {
61290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61291       };
61292     } catch (std::exception& e) {
61293       {
61294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61295       };
61296     } catch (Dali::DaliException e) {
61297       {
61298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61299       };
61300     } catch (...) {
61301       {
61302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61303       };
61304     }
61305   }
61306
61307   jresult = (int)result;
61308   return jresult;
61309 }
61310
61311
61312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61313   int jresult ;
61314   int result;
61315
61316   {
61317     try {
61318       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61319     } catch (std::out_of_range& e) {
61320       {
61321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61322       };
61323     } catch (std::exception& e) {
61324       {
61325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61326       };
61327     } catch (Dali::DaliException e) {
61328       {
61329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61330       };
61331     } catch (...) {
61332       {
61333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61334       };
61335     }
61336   }
61337
61338   jresult = (int)result;
61339   return jresult;
61340 }
61341
61342
61343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61344   int jresult ;
61345   int result;
61346
61347   {
61348     try {
61349       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61350     } catch (std::out_of_range& e) {
61351       {
61352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61353       };
61354     } catch (std::exception& e) {
61355       {
61356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61357       };
61358     } catch (Dali::DaliException e) {
61359       {
61360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61361       };
61362     } catch (...) {
61363       {
61364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61365       };
61366     }
61367   }
61368
61369   jresult = (int)result;
61370   return jresult;
61371 }
61372
61373
61374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61375   int jresult ;
61376   int result;
61377
61378   {
61379     try {
61380       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61381     } catch (std::out_of_range& e) {
61382       {
61383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61384       };
61385     } catch (std::exception& e) {
61386       {
61387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61388       };
61389     } catch (Dali::DaliException e) {
61390       {
61391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61392       };
61393     } catch (...) {
61394       {
61395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61396       };
61397     }
61398   }
61399
61400   jresult = (int)result;
61401   return jresult;
61402 }
61403
61404
61405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61406   void * jresult ;
61407   Dali::Toolkit::Builder *result = 0 ;
61408
61409   {
61410     try {
61411       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61412     } catch (std::out_of_range& e) {
61413       {
61414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61415       };
61416     } catch (std::exception& e) {
61417       {
61418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61419       };
61420     } catch (Dali::DaliException e) {
61421       {
61422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61423       };
61424     } catch (...) {
61425       {
61426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61427       };
61428     }
61429   }
61430
61431   jresult = (void *)result;
61432   return jresult;
61433 }
61434
61435
61436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61437   void * jresult ;
61438   Dali::Toolkit::Builder result;
61439
61440   {
61441     try {
61442       result = Dali::Toolkit::Builder::New();
61443     } catch (std::out_of_range& e) {
61444       {
61445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61446       };
61447     } catch (std::exception& e) {
61448       {
61449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61450       };
61451     } catch (Dali::DaliException e) {
61452       {
61453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61454       };
61455     } catch (...) {
61456       {
61457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61458       };
61459     }
61460   }
61461
61462   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61463   return jresult;
61464 }
61465
61466
61467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61468   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61469
61470   arg1 = (Dali::Toolkit::Builder *)jarg1;
61471   {
61472     try {
61473       delete arg1;
61474     } catch (std::out_of_range& e) {
61475       {
61476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61477       };
61478     } catch (std::exception& e) {
61479       {
61480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61481       };
61482     } catch (Dali::DaliException e) {
61483       {
61484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61485       };
61486     } catch (...) {
61487       {
61488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61489       };
61490     }
61491   }
61492
61493 }
61494
61495
61496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61497   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61498   std::string *arg2 = 0 ;
61499   Dali::Toolkit::Builder::UIFormat arg3 ;
61500
61501   arg1 = (Dali::Toolkit::Builder *)jarg1;
61502   if (!jarg2) {
61503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61504     return ;
61505   }
61506   std::string arg2_str(jarg2);
61507   arg2 = &arg2_str;
61508   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61509   {
61510     try {
61511       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61512     } catch (std::out_of_range& e) {
61513       {
61514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61515       };
61516     } catch (std::exception& e) {
61517       {
61518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61519       };
61520     } catch (Dali::DaliException e) {
61521       {
61522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61523       };
61524     } catch (...) {
61525       {
61526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61527       };
61528     }
61529   }
61530
61531
61532   //argout typemap for const std::string&
61533
61534 }
61535
61536
61537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61538   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61539   std::string *arg2 = 0 ;
61540
61541   arg1 = (Dali::Toolkit::Builder *)jarg1;
61542   if (!jarg2) {
61543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61544     return ;
61545   }
61546   std::string arg2_str(jarg2);
61547   arg2 = &arg2_str;
61548   {
61549     try {
61550       (arg1)->LoadFromString((std::string const &)*arg2);
61551     } catch (std::out_of_range& e) {
61552       {
61553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61554       };
61555     } catch (std::exception& e) {
61556       {
61557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61558       };
61559     } catch (Dali::DaliException e) {
61560       {
61561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61562       };
61563     } catch (...) {
61564       {
61565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61566       };
61567     }
61568   }
61569
61570
61571   //argout typemap for const std::string&
61572
61573 }
61574
61575
61576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61577   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61578   Dali::Property::Map *arg2 = 0 ;
61579
61580   arg1 = (Dali::Toolkit::Builder *)jarg1;
61581   arg2 = (Dali::Property::Map *)jarg2;
61582   if (!arg2) {
61583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61584     return ;
61585   }
61586   {
61587     try {
61588       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61589     } catch (std::out_of_range& e) {
61590       {
61591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61592       };
61593     } catch (std::exception& e) {
61594       {
61595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61596       };
61597     } catch (Dali::DaliException e) {
61598       {
61599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61600       };
61601     } catch (...) {
61602       {
61603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61604       };
61605     }
61606   }
61607
61608 }
61609
61610
61611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61612   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61613   std::string *arg2 = 0 ;
61614   Dali::Property::Value *arg3 = 0 ;
61615
61616   arg1 = (Dali::Toolkit::Builder *)jarg1;
61617   if (!jarg2) {
61618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61619     return ;
61620   }
61621   std::string arg2_str(jarg2);
61622   arg2 = &arg2_str;
61623   arg3 = (Dali::Property::Value *)jarg3;
61624   if (!arg3) {
61625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61626     return ;
61627   }
61628   {
61629     try {
61630       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61631     } catch (std::out_of_range& e) {
61632       {
61633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61634       };
61635     } catch (std::exception& e) {
61636       {
61637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61638       };
61639     } catch (Dali::DaliException e) {
61640       {
61641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61642       };
61643     } catch (...) {
61644       {
61645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61646       };
61647     }
61648   }
61649
61650
61651   //argout typemap for const std::string&
61652
61653 }
61654
61655
61656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61657   void * jresult ;
61658   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61659   Dali::Property::Map *result = 0 ;
61660
61661   arg1 = (Dali::Toolkit::Builder *)jarg1;
61662   {
61663     try {
61664       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61665     } catch (std::out_of_range& e) {
61666       {
61667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61668       };
61669     } catch (std::exception& e) {
61670       {
61671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61672       };
61673     } catch (Dali::DaliException e) {
61674       {
61675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61676       };
61677     } catch (...) {
61678       {
61679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61680       };
61681     }
61682   }
61683
61684   jresult = (void *)result;
61685   return jresult;
61686 }
61687
61688
61689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61690   void * jresult ;
61691   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61692   std::string *arg2 = 0 ;
61693   Dali::Property::Value *result = 0 ;
61694
61695   arg1 = (Dali::Toolkit::Builder *)jarg1;
61696   if (!jarg2) {
61697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61698     return 0;
61699   }
61700   std::string arg2_str(jarg2);
61701   arg2 = &arg2_str;
61702   {
61703     try {
61704       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61705     } catch (std::out_of_range& e) {
61706       {
61707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61708       };
61709     } catch (std::exception& e) {
61710       {
61711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61712       };
61713     } catch (Dali::DaliException e) {
61714       {
61715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61716       };
61717     } catch (...) {
61718       {
61719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61720       };
61721     }
61722   }
61723
61724   jresult = (void *)result;
61725
61726   //argout typemap for const std::string&
61727
61728   return jresult;
61729 }
61730
61731
61732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61733   void * jresult ;
61734   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61735   std::string *arg2 = 0 ;
61736   Dali::Animation result;
61737
61738   arg1 = (Dali::Toolkit::Builder *)jarg1;
61739   if (!jarg2) {
61740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61741     return 0;
61742   }
61743   std::string arg2_str(jarg2);
61744   arg2 = &arg2_str;
61745   {
61746     try {
61747       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61748     } catch (std::out_of_range& e) {
61749       {
61750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61751       };
61752     } catch (std::exception& e) {
61753       {
61754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61755       };
61756     } catch (Dali::DaliException e) {
61757       {
61758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61759       };
61760     } catch (...) {
61761       {
61762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61763       };
61764     }
61765   }
61766
61767   jresult = new Dali::Animation((const Dali::Animation &)result);
61768
61769   //argout typemap for const std::string&
61770
61771   return jresult;
61772 }
61773
61774
61775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61776   void * jresult ;
61777   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61778   std::string *arg2 = 0 ;
61779   Dali::Property::Map *arg3 = 0 ;
61780   Dali::Animation result;
61781
61782   arg1 = (Dali::Toolkit::Builder *)jarg1;
61783   if (!jarg2) {
61784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61785     return 0;
61786   }
61787   std::string arg2_str(jarg2);
61788   arg2 = &arg2_str;
61789   arg3 = (Dali::Property::Map *)jarg3;
61790   if (!arg3) {
61791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61792     return 0;
61793   }
61794   {
61795     try {
61796       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61797     } catch (std::out_of_range& e) {
61798       {
61799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61800       };
61801     } catch (std::exception& e) {
61802       {
61803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61804       };
61805     } catch (Dali::DaliException e) {
61806       {
61807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61808       };
61809     } catch (...) {
61810       {
61811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61812       };
61813     }
61814   }
61815
61816   jresult = new Dali::Animation((const Dali::Animation &)result);
61817
61818   //argout typemap for const std::string&
61819
61820   return jresult;
61821 }
61822
61823
61824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61825   void * jresult ;
61826   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61827   std::string *arg2 = 0 ;
61828   Dali::Actor arg3 ;
61829   Dali::Actor *argp3 ;
61830   Dali::Animation result;
61831
61832   arg1 = (Dali::Toolkit::Builder *)jarg1;
61833   if (!jarg2) {
61834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61835     return 0;
61836   }
61837   std::string arg2_str(jarg2);
61838   arg2 = &arg2_str;
61839   argp3 = (Dali::Actor *)jarg3;
61840   if (!argp3) {
61841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61842     return 0;
61843   }
61844   arg3 = *argp3;
61845   {
61846     try {
61847       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61848     } catch (std::out_of_range& e) {
61849       {
61850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61851       };
61852     } catch (std::exception& e) {
61853       {
61854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61855       };
61856     } catch (Dali::DaliException e) {
61857       {
61858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61859       };
61860     } catch (...) {
61861       {
61862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61863       };
61864     }
61865   }
61866
61867   jresult = new Dali::Animation((const Dali::Animation &)result);
61868
61869   //argout typemap for const std::string&
61870
61871   return jresult;
61872 }
61873
61874
61875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61876   void * jresult ;
61877   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61878   std::string *arg2 = 0 ;
61879   Dali::Property::Map *arg3 = 0 ;
61880   Dali::Actor arg4 ;
61881   Dali::Actor *argp4 ;
61882   Dali::Animation result;
61883
61884   arg1 = (Dali::Toolkit::Builder *)jarg1;
61885   if (!jarg2) {
61886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61887     return 0;
61888   }
61889   std::string arg2_str(jarg2);
61890   arg2 = &arg2_str;
61891   arg3 = (Dali::Property::Map *)jarg3;
61892   if (!arg3) {
61893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61894     return 0;
61895   }
61896   argp4 = (Dali::Actor *)jarg4;
61897   if (!argp4) {
61898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61899     return 0;
61900   }
61901   arg4 = *argp4;
61902   {
61903     try {
61904       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61905     } catch (std::out_of_range& e) {
61906       {
61907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61908       };
61909     } catch (std::exception& e) {
61910       {
61911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61912       };
61913     } catch (Dali::DaliException e) {
61914       {
61915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61916       };
61917     } catch (...) {
61918       {
61919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61920       };
61921     }
61922   }
61923
61924   jresult = new Dali::Animation((const Dali::Animation &)result);
61925
61926   //argout typemap for const std::string&
61927
61928   return jresult;
61929 }
61930
61931
61932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61933   void * jresult ;
61934   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61935   std::string *arg2 = 0 ;
61936   Dali::BaseHandle result;
61937
61938   arg1 = (Dali::Toolkit::Builder *)jarg1;
61939   if (!jarg2) {
61940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61941     return 0;
61942   }
61943   std::string arg2_str(jarg2);
61944   arg2 = &arg2_str;
61945   {
61946     try {
61947       result = (arg1)->Create((std::string const &)*arg2);
61948     } catch (std::out_of_range& e) {
61949       {
61950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61951       };
61952     } catch (std::exception& e) {
61953       {
61954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61955       };
61956     } catch (Dali::DaliException e) {
61957       {
61958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61959       };
61960     } catch (...) {
61961       {
61962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61963       };
61964     }
61965   }
61966
61967   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61968
61969   //argout typemap for const std::string&
61970
61971   return jresult;
61972 }
61973
61974
61975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61976   void * jresult ;
61977   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61978   std::string *arg2 = 0 ;
61979   Dali::Property::Map *arg3 = 0 ;
61980   Dali::BaseHandle result;
61981
61982   arg1 = (Dali::Toolkit::Builder *)jarg1;
61983   if (!jarg2) {
61984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61985     return 0;
61986   }
61987   std::string arg2_str(jarg2);
61988   arg2 = &arg2_str;
61989   arg3 = (Dali::Property::Map *)jarg3;
61990   if (!arg3) {
61991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61992     return 0;
61993   }
61994   {
61995     try {
61996       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61997     } catch (std::out_of_range& e) {
61998       {
61999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62000       };
62001     } catch (std::exception& e) {
62002       {
62003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62004       };
62005     } catch (Dali::DaliException e) {
62006       {
62007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62008       };
62009     } catch (...) {
62010       {
62011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62012       };
62013     }
62014   }
62015
62016   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62017
62018   //argout typemap for const std::string&
62019
62020   return jresult;
62021 }
62022
62023
62024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62025   void * jresult ;
62026   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62027   std::string *arg2 = 0 ;
62028   Dali::BaseHandle result;
62029
62030   arg1 = (Dali::Toolkit::Builder *)jarg1;
62031   if (!jarg2) {
62032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62033     return 0;
62034   }
62035   std::string arg2_str(jarg2);
62036   arg2 = &arg2_str;
62037   {
62038     try {
62039       result = (arg1)->CreateFromJson((std::string const &)*arg2);
62040     } catch (std::out_of_range& e) {
62041       {
62042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62043       };
62044     } catch (std::exception& e) {
62045       {
62046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62047       };
62048     } catch (Dali::DaliException e) {
62049       {
62050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62051       };
62052     } catch (...) {
62053       {
62054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62055       };
62056     }
62057   }
62058
62059   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62060
62061   //argout typemap for const std::string&
62062
62063   return jresult;
62064 }
62065
62066
62067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62068   unsigned int jresult ;
62069   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62070   std::string *arg2 = 0 ;
62071   Dali::Handle *arg3 = 0 ;
62072   bool result;
62073
62074   arg1 = (Dali::Toolkit::Builder *)jarg1;
62075   if (!jarg2) {
62076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62077     return 0;
62078   }
62079   std::string arg2_str(jarg2);
62080   arg2 = &arg2_str;
62081   arg3 = (Dali::Handle *)jarg3;
62082   if (!arg3) {
62083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62084     return 0;
62085   }
62086   {
62087     try {
62088       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62089     } catch (std::out_of_range& e) {
62090       {
62091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62092       };
62093     } catch (std::exception& e) {
62094       {
62095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62096       };
62097     } catch (Dali::DaliException e) {
62098       {
62099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62100       };
62101     } catch (...) {
62102       {
62103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62104       };
62105     }
62106   }
62107
62108   jresult = result;
62109
62110   //argout typemap for const std::string&
62111
62112   return jresult;
62113 }
62114
62115
62116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62117   unsigned int jresult ;
62118   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62119   Dali::Handle *arg2 = 0 ;
62120   std::string *arg3 = 0 ;
62121   bool result;
62122
62123   arg1 = (Dali::Toolkit::Builder *)jarg1;
62124   arg2 = (Dali::Handle *)jarg2;
62125   if (!arg2) {
62126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62127     return 0;
62128   }
62129   if (!jarg3) {
62130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62131     return 0;
62132   }
62133   std::string arg3_str(jarg3);
62134   arg3 = &arg3_str;
62135   {
62136     try {
62137       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62138     } catch (std::out_of_range& e) {
62139       {
62140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62141       };
62142     } catch (std::exception& e) {
62143       {
62144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62145       };
62146     } catch (Dali::DaliException e) {
62147       {
62148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62149       };
62150     } catch (...) {
62151       {
62152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62153       };
62154     }
62155   }
62156
62157   jresult = result;
62158
62159   //argout typemap for const std::string&
62160
62161   return jresult;
62162 }
62163
62164
62165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62166   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62167   Dali::Actor arg2 ;
62168   Dali::Actor *argp2 ;
62169
62170   arg1 = (Dali::Toolkit::Builder *)jarg1;
62171   argp2 = (Dali::Actor *)jarg2;
62172   if (!argp2) {
62173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62174     return ;
62175   }
62176   arg2 = *argp2;
62177   {
62178     try {
62179       (arg1)->AddActors(arg2);
62180     } catch (std::out_of_range& e) {
62181       {
62182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62183       };
62184     } catch (std::exception& e) {
62185       {
62186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62187       };
62188     } catch (Dali::DaliException e) {
62189       {
62190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62191       };
62192     } catch (...) {
62193       {
62194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62195       };
62196     }
62197   }
62198
62199 }
62200
62201
62202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62203   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62204   std::string *arg2 = 0 ;
62205   Dali::Actor arg3 ;
62206   Dali::Actor *argp3 ;
62207
62208   arg1 = (Dali::Toolkit::Builder *)jarg1;
62209   if (!jarg2) {
62210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62211     return ;
62212   }
62213   std::string arg2_str(jarg2);
62214   arg2 = &arg2_str;
62215   argp3 = (Dali::Actor *)jarg3;
62216   if (!argp3) {
62217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62218     return ;
62219   }
62220   arg3 = *argp3;
62221   {
62222     try {
62223       (arg1)->AddActors((std::string const &)*arg2,arg3);
62224     } catch (std::out_of_range& e) {
62225       {
62226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62227       };
62228     } catch (std::exception& e) {
62229       {
62230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62231       };
62232     } catch (Dali::DaliException e) {
62233       {
62234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62235       };
62236     } catch (...) {
62237       {
62238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62239       };
62240     }
62241   }
62242
62243
62244   //argout typemap for const std::string&
62245
62246 }
62247
62248
62249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62250   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62251   std::string *arg2 = 0 ;
62252
62253   arg1 = (Dali::Toolkit::Builder *)jarg1;
62254   if (!jarg2) {
62255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62256     return ;
62257   }
62258   std::string arg2_str(jarg2);
62259   arg2 = &arg2_str;
62260   {
62261     try {
62262       (arg1)->CreateRenderTask((std::string const &)*arg2);
62263     } catch (std::out_of_range& e) {
62264       {
62265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62266       };
62267     } catch (std::exception& e) {
62268       {
62269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62270       };
62271     } catch (Dali::DaliException e) {
62272       {
62273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62274       };
62275     } catch (...) {
62276       {
62277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62278       };
62279     }
62280   }
62281
62282
62283   //argout typemap for const std::string&
62284
62285 }
62286
62287
62288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62289   void * jresult ;
62290   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62291   std::string *arg2 = 0 ;
62292   Dali::FrameBufferImage result;
62293
62294   arg1 = (Dali::Toolkit::Builder *)jarg1;
62295   if (!jarg2) {
62296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62297     return 0;
62298   }
62299   std::string arg2_str(jarg2);
62300   arg2 = &arg2_str;
62301   {
62302     try {
62303       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62304     } catch (std::out_of_range& e) {
62305       {
62306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62307       };
62308     } catch (std::exception& e) {
62309       {
62310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62311       };
62312     } catch (Dali::DaliException e) {
62313       {
62314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62315       };
62316     } catch (...) {
62317       {
62318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62319       };
62320     }
62321   }
62322
62323   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62324
62325   //argout typemap for const std::string&
62326
62327   return jresult;
62328 }
62329
62330
62331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62332   void * jresult ;
62333   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62334   std::string *arg2 = 0 ;
62335   Dali::Path result;
62336
62337   arg1 = (Dali::Toolkit::Builder *)jarg1;
62338   if (!jarg2) {
62339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62340     return 0;
62341   }
62342   std::string arg2_str(jarg2);
62343   arg2 = &arg2_str;
62344   {
62345     try {
62346       result = (arg1)->GetPath((std::string const &)*arg2);
62347     } catch (std::out_of_range& e) {
62348       {
62349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62350       };
62351     } catch (std::exception& e) {
62352       {
62353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62354       };
62355     } catch (Dali::DaliException e) {
62356       {
62357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62358       };
62359     } catch (...) {
62360       {
62361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62362       };
62363     }
62364   }
62365
62366   jresult = new Dali::Path((const Dali::Path &)result);
62367
62368   //argout typemap for const std::string&
62369
62370   return jresult;
62371 }
62372
62373
62374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62375   void * jresult ;
62376   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62377   std::string *arg2 = 0 ;
62378   Dali::PathConstrainer result;
62379
62380   arg1 = (Dali::Toolkit::Builder *)jarg1;
62381   if (!jarg2) {
62382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62383     return 0;
62384   }
62385   std::string arg2_str(jarg2);
62386   arg2 = &arg2_str;
62387   {
62388     try {
62389       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62390     } catch (std::out_of_range& e) {
62391       {
62392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62393       };
62394     } catch (std::exception& e) {
62395       {
62396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62397       };
62398     } catch (Dali::DaliException e) {
62399       {
62400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62401       };
62402     } catch (...) {
62403       {
62404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62405       };
62406     }
62407   }
62408
62409   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62410
62411   //argout typemap for const std::string&
62412
62413   return jresult;
62414 }
62415
62416
62417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62418   void * jresult ;
62419   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62420   std::string *arg2 = 0 ;
62421   Dali::LinearConstrainer result;
62422
62423   arg1 = (Dali::Toolkit::Builder *)jarg1;
62424   if (!jarg2) {
62425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62426     return 0;
62427   }
62428   std::string arg2_str(jarg2);
62429   arg2 = &arg2_str;
62430   {
62431     try {
62432       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62433     } catch (std::out_of_range& e) {
62434       {
62435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62436       };
62437     } catch (std::exception& e) {
62438       {
62439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62440       };
62441     } catch (Dali::DaliException e) {
62442       {
62443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62444       };
62445     } catch (...) {
62446       {
62447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62448       };
62449     }
62450   }
62451
62452   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62453
62454   //argout typemap for const std::string&
62455
62456   return jresult;
62457 }
62458
62459
62460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62461   void * jresult ;
62462   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62463   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62464
62465   arg1 = (Dali::Toolkit::Builder *)jarg1;
62466   {
62467     try {
62468       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62469     } catch (std::out_of_range& e) {
62470       {
62471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62472       };
62473     } catch (std::exception& e) {
62474       {
62475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62476       };
62477     } catch (Dali::DaliException e) {
62478       {
62479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62480       };
62481     } catch (...) {
62482       {
62483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62484       };
62485     }
62486   }
62487
62488   jresult = (void *)result;
62489   return jresult;
62490 }
62491
62492
62493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62494   void * jresult ;
62495   Dali::Toolkit::TransitionData *result = 0 ;
62496
62497   {
62498     try {
62499       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62500     } catch (std::out_of_range& e) {
62501       {
62502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62503       };
62504     } catch (std::exception& e) {
62505       {
62506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62507       };
62508     } catch (Dali::DaliException e) {
62509       {
62510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62511       };
62512     } catch (...) {
62513       {
62514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62515       };
62516     }
62517   }
62518
62519   jresult = (void *)result;
62520   return jresult;
62521 }
62522
62523
62524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62525   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62526
62527   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62528   {
62529     try {
62530       delete arg1;
62531     } catch (std::out_of_range& e) {
62532       {
62533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62534       };
62535     } catch (std::exception& e) {
62536       {
62537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62538       };
62539     } catch (Dali::DaliException e) {
62540       {
62541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62542       };
62543     } catch (...) {
62544       {
62545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62546       };
62547     }
62548   }
62549
62550 }
62551
62552
62553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62554   void * jresult ;
62555   Dali::Property::Map *arg1 = 0 ;
62556   Dali::Toolkit::TransitionData result;
62557
62558   arg1 = (Dali::Property::Map *)jarg1;
62559   if (!arg1) {
62560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62561     return 0;
62562   }
62563   {
62564     try {
62565       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62566     } catch (std::out_of_range& e) {
62567       {
62568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62569       };
62570     } catch (std::exception& e) {
62571       {
62572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62573       };
62574     } catch (Dali::DaliException e) {
62575       {
62576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62577       };
62578     } catch (...) {
62579       {
62580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62581       };
62582     }
62583   }
62584
62585   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62586   return jresult;
62587 }
62588
62589
62590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62591   void * jresult ;
62592   Dali::Property::Array *arg1 = 0 ;
62593   Dali::Toolkit::TransitionData result;
62594
62595   arg1 = (Dali::Property::Array *)jarg1;
62596   if (!arg1) {
62597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62598     return 0;
62599   }
62600   {
62601     try {
62602       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62603     } catch (std::out_of_range& e) {
62604       {
62605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62606       };
62607     } catch (std::exception& e) {
62608       {
62609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62610       };
62611     } catch (Dali::DaliException e) {
62612       {
62613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62614       };
62615     } catch (...) {
62616       {
62617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62618       };
62619     }
62620   }
62621
62622   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62623   return jresult;
62624 }
62625
62626
62627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62628   void * jresult ;
62629   Dali::BaseHandle arg1 ;
62630   Dali::BaseHandle *argp1 ;
62631   Dali::Toolkit::TransitionData result;
62632
62633   argp1 = (Dali::BaseHandle *)jarg1;
62634   if (!argp1) {
62635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62636     return 0;
62637   }
62638   arg1 = *argp1;
62639   {
62640     try {
62641       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62642     } catch (std::out_of_range& e) {
62643       {
62644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62645       };
62646     } catch (std::exception& e) {
62647       {
62648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62649       };
62650     } catch (Dali::DaliException e) {
62651       {
62652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62653       };
62654     } catch (...) {
62655       {
62656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62657       };
62658     }
62659   }
62660
62661   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62662   return jresult;
62663 }
62664
62665
62666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62667   void * jresult ;
62668   Dali::Toolkit::TransitionData *arg1 = 0 ;
62669   Dali::Toolkit::TransitionData *result = 0 ;
62670
62671   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62672   if (!arg1) {
62673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62674     return 0;
62675   }
62676   {
62677     try {
62678       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62679     } catch (std::out_of_range& e) {
62680       {
62681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62682       };
62683     } catch (std::exception& e) {
62684       {
62685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62686       };
62687     } catch (Dali::DaliException e) {
62688       {
62689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62690       };
62691     } catch (...) {
62692       {
62693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62694       };
62695     }
62696   }
62697
62698   jresult = (void *)result;
62699   return jresult;
62700 }
62701
62702
62703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62704   void * jresult ;
62705   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62706   Dali::Toolkit::TransitionData *arg2 = 0 ;
62707   Dali::Toolkit::TransitionData *result = 0 ;
62708
62709   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62710   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62711   if (!arg2) {
62712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62713     return 0;
62714   }
62715   {
62716     try {
62717       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62718     } catch (std::out_of_range& e) {
62719       {
62720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62721       };
62722     } catch (std::exception& e) {
62723       {
62724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62725       };
62726     } catch (Dali::DaliException e) {
62727       {
62728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62729       };
62730     } catch (...) {
62731       {
62732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62733       };
62734     }
62735   }
62736
62737   jresult = (void *)result;
62738   return jresult;
62739 }
62740
62741
62742 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62743   unsigned long jresult ;
62744   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62745   size_t result;
62746
62747   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62748   {
62749     try {
62750       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62751     } catch (std::out_of_range& e) {
62752       {
62753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62754       };
62755     } catch (std::exception& e) {
62756       {
62757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62758       };
62759     } catch (Dali::DaliException e) {
62760       {
62761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62762       };
62763     } catch (...) {
62764       {
62765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62766       };
62767     }
62768   }
62769
62770   jresult = (unsigned long)result;
62771   return jresult;
62772 }
62773
62774
62775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62776   void * jresult ;
62777   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62778   size_t arg2 ;
62779   Dali::Property::Map result;
62780
62781   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62782   arg2 = (size_t)jarg2;
62783   {
62784     try {
62785       result = (arg1)->GetAnimatorAt(arg2);
62786     } catch (std::out_of_range& e) {
62787       {
62788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62789       };
62790     } catch (std::exception& e) {
62791       {
62792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62793       };
62794     } catch (Dali::DaliException e) {
62795       {
62796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62797       };
62798     } catch (...) {
62799       {
62800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62801       };
62802     }
62803   }
62804
62805   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62806   return jresult;
62807 }
62808
62809
62810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
62811   void * jresult ;
62812   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
62813   Dali::Toolkit::TransitionData *result = 0 ;
62814
62815   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
62816   {
62817     try {
62818       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
62819     } catch (std::out_of_range& e) {
62820       {
62821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62822       };
62823     } catch (std::exception& e) {
62824       {
62825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62826       };
62827     } catch (Dali::DaliException e) {
62828       {
62829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62830       };
62831     } catch (...) {
62832       {
62833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62834       };
62835     }
62836   }
62837
62838   jresult = (void *)result;
62839   return jresult;
62840 }
62841
62842
62843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62844   int jresult ;
62845   int result;
62846
62847   {
62848     try {
62849       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62850     } catch (std::out_of_range& e) {
62851       {
62852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62853       };
62854     } catch (std::exception& e) {
62855       {
62856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62857       };
62858     } catch (Dali::DaliException e) {
62859       {
62860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62861       };
62862     } catch (...) {
62863       {
62864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62865       };
62866     }
62867   }
62868
62869   jresult = (int)result;
62870   return jresult;
62871 }
62872
62873
62874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62875   int jresult ;
62876   int result;
62877
62878   {
62879     try {
62880       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62881     } catch (std::out_of_range& e) {
62882       {
62883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62884       };
62885     } catch (std::exception& e) {
62886       {
62887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62888       };
62889     } catch (Dali::DaliException e) {
62890       {
62891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62892       };
62893     } catch (...) {
62894       {
62895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62896       };
62897     }
62898   }
62899
62900   jresult = (int)result;
62901   return jresult;
62902 }
62903
62904
62905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62906   int jresult ;
62907   int result;
62908
62909   {
62910     try {
62911       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62912     } catch (std::out_of_range& e) {
62913       {
62914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62915       };
62916     } catch (std::exception& e) {
62917       {
62918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62919       };
62920     } catch (Dali::DaliException e) {
62921       {
62922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62923       };
62924     } catch (...) {
62925       {
62926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62927       };
62928     }
62929   }
62930
62931   jresult = (int)result;
62932   return jresult;
62933 }
62934
62935
62936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62937   int jresult ;
62938   int result;
62939
62940   {
62941     try {
62942       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62943     } catch (std::out_of_range& e) {
62944       {
62945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62946       };
62947     } catch (std::exception& e) {
62948       {
62949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62950       };
62951     } catch (Dali::DaliException e) {
62952       {
62953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62954       };
62955     } catch (...) {
62956       {
62957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62958       };
62959     }
62960   }
62961
62962   jresult = (int)result;
62963   return jresult;
62964 }
62965
62966
62967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62968   int jresult ;
62969   int result;
62970
62971   {
62972     try {
62973       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62974     } catch (std::out_of_range& e) {
62975       {
62976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62977       };
62978     } catch (std::exception& e) {
62979       {
62980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62981       };
62982     } catch (Dali::DaliException e) {
62983       {
62984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62985       };
62986     } catch (...) {
62987       {
62988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62989       };
62990     }
62991   }
62992
62993   jresult = (int)result;
62994   return jresult;
62995 }
62996
62997
62998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62999   int jresult ;
63000   int result;
63001
63002   {
63003     try {
63004       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63005     } catch (std::out_of_range& e) {
63006       {
63007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63008       };
63009     } catch (std::exception& e) {
63010       {
63011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63012       };
63013     } catch (Dali::DaliException e) {
63014       {
63015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63016       };
63017     } catch (...) {
63018       {
63019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63020       };
63021     }
63022   }
63023
63024   jresult = (int)result;
63025   return jresult;
63026 }
63027
63028
63029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63030   int jresult ;
63031   int result;
63032
63033   {
63034     try {
63035       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63036     } catch (std::out_of_range& e) {
63037       {
63038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63039       };
63040     } catch (std::exception& e) {
63041       {
63042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63043       };
63044     } catch (Dali::DaliException e) {
63045       {
63046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63047       };
63048     } catch (...) {
63049       {
63050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63051       };
63052     }
63053   }
63054
63055   jresult = (int)result;
63056   return jresult;
63057 }
63058
63059
63060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63061   int jresult ;
63062   int result;
63063
63064   {
63065     try {
63066       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63067     } catch (std::out_of_range& e) {
63068       {
63069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63070       };
63071     } catch (std::exception& e) {
63072       {
63073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63074       };
63075     } catch (Dali::DaliException e) {
63076       {
63077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63078       };
63079     } catch (...) {
63080       {
63081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63082       };
63083     }
63084   }
63085
63086   jresult = (int)result;
63087   return jresult;
63088 }
63089
63090
63091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63092   int jresult ;
63093   int result;
63094
63095   {
63096     try {
63097       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63098     } catch (std::out_of_range& e) {
63099       {
63100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63101       };
63102     } catch (std::exception& e) {
63103       {
63104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63105       };
63106     } catch (Dali::DaliException e) {
63107       {
63108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63109       };
63110     } catch (...) {
63111       {
63112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63113       };
63114     }
63115   }
63116
63117   jresult = (int)result;
63118   return jresult;
63119 }
63120
63121
63122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63123   int jresult ;
63124   int result;
63125
63126   {
63127     try {
63128       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63129     } catch (std::out_of_range& e) {
63130       {
63131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63132       };
63133     } catch (std::exception& e) {
63134       {
63135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63136       };
63137     } catch (Dali::DaliException e) {
63138       {
63139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63140       };
63141     } catch (...) {
63142       {
63143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63144       };
63145     }
63146   }
63147
63148   jresult = (int)result;
63149   return jresult;
63150 }
63151
63152
63153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63154   int jresult ;
63155   int result;
63156
63157   {
63158     try {
63159       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63160     } catch (std::out_of_range& e) {
63161       {
63162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63163       };
63164     } catch (std::exception& e) {
63165       {
63166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63167       };
63168     } catch (Dali::DaliException e) {
63169       {
63170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63171       };
63172     } catch (...) {
63173       {
63174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63175       };
63176     }
63177   }
63178
63179   jresult = (int)result;
63180   return jresult;
63181 }
63182
63183
63184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63185   int jresult ;
63186   int result;
63187
63188   {
63189     try {
63190       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63191     } catch (std::out_of_range& e) {
63192       {
63193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63194       };
63195     } catch (std::exception& e) {
63196       {
63197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63198       };
63199     } catch (Dali::DaliException e) {
63200       {
63201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63202       };
63203     } catch (...) {
63204       {
63205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63206       };
63207     }
63208   }
63209
63210   jresult = (int)result;
63211   return jresult;
63212 }
63213
63214
63215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63216   int jresult ;
63217   int result;
63218
63219   {
63220     try {
63221       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63222     } catch (std::out_of_range& e) {
63223       {
63224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63225       };
63226     } catch (std::exception& e) {
63227       {
63228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63229       };
63230     } catch (Dali::DaliException e) {
63231       {
63232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63233       };
63234     } catch (...) {
63235       {
63236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63237       };
63238     }
63239   }
63240
63241   jresult = (int)result;
63242   return jresult;
63243 }
63244
63245
63246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63247   int jresult ;
63248   int result;
63249
63250   {
63251     try {
63252       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63253     } catch (std::out_of_range& e) {
63254       {
63255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63256       };
63257     } catch (std::exception& e) {
63258       {
63259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63260       };
63261     } catch (Dali::DaliException e) {
63262       {
63263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63264       };
63265     } catch (...) {
63266       {
63267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63268       };
63269     }
63270   }
63271
63272   jresult = (int)result;
63273   return jresult;
63274 }
63275
63276
63277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63278   void * jresult ;
63279   Dali::Toolkit::Control result;
63280
63281   {
63282     try {
63283       result = Dali::Toolkit::Internal::Control::New();
63284     } catch (std::out_of_range& e) {
63285       {
63286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63287       };
63288     } catch (std::exception& e) {
63289       {
63290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63291       };
63292     } catch (Dali::DaliException e) {
63293       {
63294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63295       };
63296     } catch (...) {
63297       {
63298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63299       };
63300     }
63301   }
63302
63303   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63304   return jresult;
63305 }
63306
63307
63308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63309   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63310   std::string *arg2 = 0 ;
63311
63312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63313   if (!jarg2) {
63314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63315     return ;
63316   }
63317   std::string arg2_str(jarg2);
63318   arg2 = &arg2_str;
63319   {
63320     try {
63321       (arg1)->SetStyleName((std::string const &)*arg2);
63322     } catch (std::out_of_range& e) {
63323       {
63324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63325       };
63326     } catch (std::exception& e) {
63327       {
63328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63329       };
63330     } catch (Dali::DaliException e) {
63331       {
63332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63333       };
63334     } catch (...) {
63335       {
63336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63337       };
63338     }
63339   }
63340
63341
63342   //argout typemap for const std::string&
63343
63344 }
63345
63346
63347 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63348   char * jresult ;
63349   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63350   std::string *result = 0 ;
63351
63352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63353   {
63354     try {
63355       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63356     } catch (std::out_of_range& e) {
63357       {
63358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63359       };
63360     } catch (std::exception& e) {
63361       {
63362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63363       };
63364     } catch (Dali::DaliException e) {
63365       {
63366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63367       };
63368     } catch (...) {
63369       {
63370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63371       };
63372     }
63373   }
63374
63375   jresult = SWIG_csharp_string_callback(result->c_str());
63376   return jresult;
63377 }
63378
63379
63380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63381   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63382   Dali::Vector4 *arg2 = 0 ;
63383
63384   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63385   arg2 = (Dali::Vector4 *)jarg2;
63386   if (!arg2) {
63387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63388     return ;
63389   }
63390   {
63391     try {
63392       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63393     } catch (std::out_of_range& e) {
63394       {
63395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63396       };
63397     } catch (std::exception& e) {
63398       {
63399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63400       };
63401     } catch (Dali::DaliException e) {
63402       {
63403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63404       };
63405     } catch (...) {
63406       {
63407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63408       };
63409     }
63410   }
63411
63412 }
63413
63414
63415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63416   void * jresult ;
63417   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63418   Dali::Vector4 result;
63419
63420   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63421   {
63422     try {
63423       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63424     } catch (std::out_of_range& e) {
63425       {
63426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63427       };
63428     } catch (std::exception& e) {
63429       {
63430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63431       };
63432     } catch (Dali::DaliException e) {
63433       {
63434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63435       };
63436     } catch (...) {
63437       {
63438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63439       };
63440     }
63441   }
63442
63443   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63444   return jresult;
63445 }
63446
63447
63448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63449   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63450   Dali::Image arg2 ;
63451   Dali::Image *argp2 ;
63452
63453   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63454   argp2 = (Dali::Image *)jarg2;
63455   if (!argp2) {
63456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63457     return ;
63458   }
63459   arg2 = *argp2;
63460   {
63461     try {
63462       (arg1)->SetBackgroundImage(arg2);
63463     } catch (std::out_of_range& e) {
63464       {
63465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63466       };
63467     } catch (std::exception& e) {
63468       {
63469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63470       };
63471     } catch (Dali::DaliException e) {
63472       {
63473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63474       };
63475     } catch (...) {
63476       {
63477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63478       };
63479     }
63480   }
63481
63482 }
63483
63484
63485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63486   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63487   Dali::Property::Map *arg2 = 0 ;
63488
63489   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63490   arg2 = (Dali::Property::Map *)jarg2;
63491   if (!arg2) {
63492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63493     return ;
63494   }
63495   {
63496     try {
63497       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63498     } catch (std::out_of_range& e) {
63499       {
63500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63501       };
63502     } catch (std::exception& e) {
63503       {
63504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63505       };
63506     } catch (Dali::DaliException e) {
63507       {
63508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63509       };
63510     } catch (...) {
63511       {
63512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63513       };
63514     }
63515   }
63516
63517 }
63518
63519
63520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63521   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63522
63523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63524   {
63525     try {
63526       (arg1)->ClearBackground();
63527     } catch (std::out_of_range& e) {
63528       {
63529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63530       };
63531     } catch (std::exception& e) {
63532       {
63533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63534       };
63535     } catch (Dali::DaliException e) {
63536       {
63537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63538       };
63539     } catch (...) {
63540       {
63541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63542       };
63543     }
63544   }
63545
63546 }
63547
63548
63549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63550   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63551   Dali::Gesture::Type arg2 ;
63552
63553   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63554   arg2 = (Dali::Gesture::Type)jarg2;
63555   {
63556     try {
63557       (arg1)->EnableGestureDetection(arg2);
63558     } catch (std::out_of_range& e) {
63559       {
63560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63561       };
63562     } catch (std::exception& e) {
63563       {
63564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63565       };
63566     } catch (Dali::DaliException e) {
63567       {
63568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63569       };
63570     } catch (...) {
63571       {
63572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63573       };
63574     }
63575   }
63576
63577 }
63578
63579
63580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63581   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63582   Dali::Gesture::Type arg2 ;
63583
63584   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63585   arg2 = (Dali::Gesture::Type)jarg2;
63586   {
63587     try {
63588       (arg1)->DisableGestureDetection(arg2);
63589     } catch (std::out_of_range& e) {
63590       {
63591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63592       };
63593     } catch (std::exception& e) {
63594       {
63595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63596       };
63597     } catch (Dali::DaliException e) {
63598       {
63599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63600       };
63601     } catch (...) {
63602       {
63603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63604       };
63605     }
63606   }
63607
63608 }
63609
63610
63611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63612   void * jresult ;
63613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63614   Dali::PinchGestureDetector result;
63615
63616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63617   {
63618     try {
63619       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63620     } catch (std::out_of_range& e) {
63621       {
63622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63623       };
63624     } catch (std::exception& e) {
63625       {
63626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63627       };
63628     } catch (Dali::DaliException e) {
63629       {
63630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63631       };
63632     } catch (...) {
63633       {
63634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63635       };
63636     }
63637   }
63638
63639   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63640   return jresult;
63641 }
63642
63643
63644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63645   void * jresult ;
63646   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63647   Dali::PanGestureDetector result;
63648
63649   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63650   {
63651     try {
63652       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63653     } catch (std::out_of_range& e) {
63654       {
63655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63656       };
63657     } catch (std::exception& e) {
63658       {
63659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63660       };
63661     } catch (Dali::DaliException e) {
63662       {
63663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63664       };
63665     } catch (...) {
63666       {
63667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63668       };
63669     }
63670   }
63671
63672   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63673   return jresult;
63674 }
63675
63676
63677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63678   void * jresult ;
63679   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63680   Dali::TapGestureDetector result;
63681
63682   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63683   {
63684     try {
63685       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63686     } catch (std::out_of_range& e) {
63687       {
63688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63689       };
63690     } catch (std::exception& e) {
63691       {
63692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63693       };
63694     } catch (Dali::DaliException e) {
63695       {
63696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63697       };
63698     } catch (...) {
63699       {
63700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63701       };
63702     }
63703   }
63704
63705   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63706   return jresult;
63707 }
63708
63709
63710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63711   void * jresult ;
63712   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63713   Dali::LongPressGestureDetector result;
63714
63715   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63716   {
63717     try {
63718       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63719     } catch (std::out_of_range& e) {
63720       {
63721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63722       };
63723     } catch (std::exception& e) {
63724       {
63725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63726       };
63727     } catch (Dali::DaliException e) {
63728       {
63729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63730       };
63731     } catch (...) {
63732       {
63733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63734       };
63735     }
63736   }
63737
63738   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63739   return jresult;
63740 }
63741
63742
63743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63745   bool arg2 ;
63746
63747   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63748   arg2 = jarg2 ? true : false;
63749   {
63750     try {
63751       (arg1)->SetKeyboardNavigationSupport(arg2);
63752     } catch (std::out_of_range& e) {
63753       {
63754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63755       };
63756     } catch (std::exception& e) {
63757       {
63758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63759       };
63760     } catch (Dali::DaliException e) {
63761       {
63762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63763       };
63764     } catch (...) {
63765       {
63766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63767       };
63768     }
63769   }
63770
63771 }
63772
63773
63774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63775   unsigned int jresult ;
63776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63777   bool result;
63778
63779   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63780   {
63781     try {
63782       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63783     } catch (std::out_of_range& e) {
63784       {
63785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63786       };
63787     } catch (std::exception& e) {
63788       {
63789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63790       };
63791     } catch (Dali::DaliException e) {
63792       {
63793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63794       };
63795     } catch (...) {
63796       {
63797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63798       };
63799     }
63800   }
63801
63802   jresult = result;
63803   return jresult;
63804 }
63805
63806
63807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63808   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63809
63810   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63811   {
63812     try {
63813       (arg1)->SetKeyInputFocus();
63814     } catch (std::out_of_range& e) {
63815       {
63816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63817       };
63818     } catch (std::exception& e) {
63819       {
63820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63821       };
63822     } catch (Dali::DaliException e) {
63823       {
63824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63825       };
63826     } catch (...) {
63827       {
63828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63829       };
63830     }
63831   }
63832
63833 }
63834
63835
63836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63837   unsigned int jresult ;
63838   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63839   bool result;
63840
63841   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63842   {
63843     try {
63844       result = (bool)(arg1)->HasKeyInputFocus();
63845     } catch (std::out_of_range& e) {
63846       {
63847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63848       };
63849     } catch (std::exception& e) {
63850       {
63851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63852       };
63853     } catch (Dali::DaliException e) {
63854       {
63855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63856       };
63857     } catch (...) {
63858       {
63859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63860       };
63861     }
63862   }
63863
63864   jresult = result;
63865   return jresult;
63866 }
63867
63868
63869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63871
63872   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63873   {
63874     try {
63875       (arg1)->ClearKeyInputFocus();
63876     } catch (std::out_of_range& e) {
63877       {
63878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63879       };
63880     } catch (std::exception& e) {
63881       {
63882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63883       };
63884     } catch (Dali::DaliException e) {
63885       {
63886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63887       };
63888     } catch (...) {
63889       {
63890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63891       };
63892     }
63893   }
63894
63895 }
63896
63897
63898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63899   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63900   bool arg2 ;
63901
63902   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63903   arg2 = jarg2 ? true : false;
63904   {
63905     try {
63906       (arg1)->SetAsKeyboardFocusGroup(arg2);
63907     } catch (std::out_of_range& e) {
63908       {
63909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63910       };
63911     } catch (std::exception& e) {
63912       {
63913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63914       };
63915     } catch (Dali::DaliException e) {
63916       {
63917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63918       };
63919     } catch (...) {
63920       {
63921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63922       };
63923     }
63924   }
63925
63926 }
63927
63928
63929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63930   unsigned int jresult ;
63931   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63932   bool result;
63933
63934   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63935   {
63936     try {
63937       result = (bool)(arg1)->IsKeyboardFocusGroup();
63938     } catch (std::out_of_range& e) {
63939       {
63940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63941       };
63942     } catch (std::exception& e) {
63943       {
63944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63945       };
63946     } catch (Dali::DaliException e) {
63947       {
63948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63949       };
63950     } catch (...) {
63951       {
63952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63953       };
63954     }
63955   }
63956
63957   jresult = result;
63958   return jresult;
63959 }
63960
63961
63962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
63963   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63964
63965   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63966   {
63967     try {
63968       (arg1)->AccessibilityActivate();
63969     } catch (std::out_of_range& e) {
63970       {
63971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63972       };
63973     } catch (std::exception& e) {
63974       {
63975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63976       };
63977     } catch (Dali::DaliException e) {
63978       {
63979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63980       };
63981     } catch (...) {
63982       {
63983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63984       };
63985     }
63986   }
63987
63988 }
63989
63990
63991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
63992   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63993
63994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63995   {
63996     try {
63997       (arg1)->KeyboardEnter();
63998     } catch (std::out_of_range& e) {
63999       {
64000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64001       };
64002     } catch (std::exception& e) {
64003       {
64004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64005       };
64006     } catch (Dali::DaliException e) {
64007       {
64008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64009       };
64010     } catch (...) {
64011       {
64012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64013       };
64014     }
64015   }
64016
64017 }
64018
64019
64020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64021   void * jresult ;
64022   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64023   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64024
64025   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64026   {
64027     try {
64028       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64029     } catch (std::out_of_range& e) {
64030       {
64031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64032       };
64033     } catch (std::exception& e) {
64034       {
64035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64036       };
64037     } catch (Dali::DaliException e) {
64038       {
64039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64040       };
64041     } catch (...) {
64042       {
64043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64044       };
64045     }
64046   }
64047
64048   jresult = (void *)result;
64049   return jresult;
64050 }
64051
64052
64053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64054   void * jresult ;
64055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64056   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64057
64058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64059   {
64060     try {
64061       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64062     } catch (std::out_of_range& e) {
64063       {
64064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64065       };
64066     } catch (std::exception& e) {
64067       {
64068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64069       };
64070     } catch (Dali::DaliException e) {
64071       {
64072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64073       };
64074     } catch (...) {
64075       {
64076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64077       };
64078     }
64079   }
64080
64081   jresult = (void *)result;
64082   return jresult;
64083 }
64084
64085
64086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64087   void * jresult ;
64088   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64089   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64090
64091   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64092   {
64093     try {
64094       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64095     } catch (std::out_of_range& e) {
64096       {
64097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64098       };
64099     } catch (std::exception& e) {
64100       {
64101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64102       };
64103     } catch (Dali::DaliException e) {
64104       {
64105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64106       };
64107     } catch (...) {
64108       {
64109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64110       };
64111     }
64112   }
64113
64114   jresult = (void *)result;
64115   return jresult;
64116 }
64117
64118
64119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
64120   unsigned int jresult ;
64121   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64122   Dali::KeyEvent *arg2 = 0 ;
64123   bool result;
64124
64125   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64126   arg2 = (Dali::KeyEvent *)jarg2;
64127   if (!arg2) {
64128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64129     return 0;
64130   }
64131   {
64132     try {
64133       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
64134     } catch (std::out_of_range& e) {
64135       {
64136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64137       };
64138     } catch (std::exception& e) {
64139       {
64140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64141       };
64142     } catch (Dali::DaliException e) {
64143       {
64144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64145       };
64146     } catch (...) {
64147       {
64148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64149       };
64150     }
64151   }
64152
64153   jresult = result;
64154   return jresult;
64155 }
64156
64157
64158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64159   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64160   int arg2 ;
64161   SwigDirector_ViewImpl *darg = 0;
64162
64163   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64164   arg2 = (int)jarg2;
64165   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64166   {
64167     try {
64168       (darg)->OnStageConnection(arg2);
64169     } catch (std::out_of_range& e) {
64170       {
64171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64172       };
64173     } catch (std::exception& e) {
64174       {
64175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64176       };
64177     } catch (Dali::DaliException e) {
64178       {
64179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64180       };
64181     } catch (...) {
64182       {
64183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64184       };
64185     }
64186   }
64187
64188 }
64189
64190
64191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64192   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64193   int arg2 ;
64194   SwigDirector_ViewImpl *darg = 0;
64195
64196   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64197   arg2 = (int)jarg2;
64198   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64199   {
64200     try {
64201       (darg)->OnStageConnectionSwigPublic(arg2);
64202     } catch (std::out_of_range& e) {
64203       {
64204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64205       };
64206     } catch (std::exception& e) {
64207       {
64208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64209       };
64210     } catch (Dali::DaliException e) {
64211       {
64212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64213       };
64214     } catch (...) {
64215       {
64216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64217       };
64218     }
64219   }
64220
64221 }
64222
64223
64224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64225   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64226   SwigDirector_ViewImpl *darg = 0;
64227
64228   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64229   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64230   {
64231     try {
64232       (darg)->OnStageDisconnection();
64233     } catch (std::out_of_range& e) {
64234       {
64235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64236       };
64237     } catch (std::exception& e) {
64238       {
64239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64240       };
64241     } catch (Dali::DaliException e) {
64242       {
64243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64244       };
64245     } catch (...) {
64246       {
64247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64248       };
64249     }
64250   }
64251
64252 }
64253
64254
64255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64256   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64257   SwigDirector_ViewImpl *darg = 0;
64258
64259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64260   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64261   {
64262     try {
64263       (darg)->OnStageDisconnectionSwigPublic();
64264     } catch (std::out_of_range& e) {
64265       {
64266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64267       };
64268     } catch (std::exception& e) {
64269       {
64270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64271       };
64272     } catch (Dali::DaliException e) {
64273       {
64274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64275       };
64276     } catch (...) {
64277       {
64278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64279       };
64280     }
64281   }
64282
64283 }
64284
64285
64286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64287   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64288   Dali::Actor *arg2 = 0 ;
64289   SwigDirector_ViewImpl *darg = 0;
64290
64291   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64292   arg2 = (Dali::Actor *)jarg2;
64293   if (!arg2) {
64294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64295     return ;
64296   }
64297   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64298   {
64299     try {
64300       (darg)->OnChildAdd(*arg2);
64301     } catch (std::out_of_range& e) {
64302       {
64303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64304       };
64305     } catch (std::exception& e) {
64306       {
64307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64308       };
64309     } catch (Dali::DaliException e) {
64310       {
64311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64312       };
64313     } catch (...) {
64314       {
64315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64316       };
64317     }
64318   }
64319
64320 }
64321
64322
64323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64324   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64325   Dali::Actor *arg2 = 0 ;
64326   SwigDirector_ViewImpl *darg = 0;
64327
64328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64329   arg2 = (Dali::Actor *)jarg2;
64330   if (!arg2) {
64331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64332     return ;
64333   }
64334   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64335   {
64336     try {
64337       (darg)->OnChildAddSwigPublic(*arg2);
64338     } catch (std::out_of_range& e) {
64339       {
64340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64341       };
64342     } catch (std::exception& e) {
64343       {
64344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64345       };
64346     } catch (Dali::DaliException e) {
64347       {
64348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64349       };
64350     } catch (...) {
64351       {
64352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64353       };
64354     }
64355   }
64356
64357 }
64358
64359
64360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64361   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64362   Dali::Actor *arg2 = 0 ;
64363   SwigDirector_ViewImpl *darg = 0;
64364
64365   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64366   arg2 = (Dali::Actor *)jarg2;
64367   if (!arg2) {
64368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64369     return ;
64370   }
64371   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64372   {
64373     try {
64374       (darg)->OnChildRemove(*arg2);
64375     } catch (std::out_of_range& e) {
64376       {
64377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64378       };
64379     } catch (std::exception& e) {
64380       {
64381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64382       };
64383     } catch (Dali::DaliException e) {
64384       {
64385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64386       };
64387     } catch (...) {
64388       {
64389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64390       };
64391     }
64392   }
64393
64394 }
64395
64396
64397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64399   Dali::Actor *arg2 = 0 ;
64400   SwigDirector_ViewImpl *darg = 0;
64401
64402   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64403   arg2 = (Dali::Actor *)jarg2;
64404   if (!arg2) {
64405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64406     return ;
64407   }
64408   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64409   {
64410     try {
64411       (darg)->OnChildRemoveSwigPublic(*arg2);
64412     } catch (std::out_of_range& e) {
64413       {
64414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64415       };
64416     } catch (std::exception& e) {
64417       {
64418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64419       };
64420     } catch (Dali::DaliException e) {
64421       {
64422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64423       };
64424     } catch (...) {
64425       {
64426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64427       };
64428     }
64429   }
64430
64431 }
64432
64433
64434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64435   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64436   Dali::Property::Index arg2 ;
64437   Dali::Property::Value arg3 ;
64438   Dali::Property::Value *argp3 ;
64439   SwigDirector_ViewImpl *darg = 0;
64440
64441   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64442   arg2 = (Dali::Property::Index)jarg2;
64443   argp3 = (Dali::Property::Value *)jarg3;
64444   if (!argp3) {
64445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64446     return ;
64447   }
64448   arg3 = *argp3;
64449   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64450   {
64451     try {
64452       (darg)->OnPropertySet(arg2,arg3);
64453     } catch (std::out_of_range& e) {
64454       {
64455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64456       };
64457     } catch (std::exception& e) {
64458       {
64459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64460       };
64461     } catch (Dali::DaliException e) {
64462       {
64463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64464       };
64465     } catch (...) {
64466       {
64467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64468       };
64469     }
64470   }
64471
64472 }
64473
64474
64475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64476   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64477   Dali::Property::Index arg2 ;
64478   Dali::Property::Value arg3 ;
64479   Dali::Property::Value *argp3 ;
64480   SwigDirector_ViewImpl *darg = 0;
64481
64482   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64483   arg2 = (Dali::Property::Index)jarg2;
64484   argp3 = (Dali::Property::Value *)jarg3;
64485   if (!argp3) {
64486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64487     return ;
64488   }
64489   arg3 = *argp3;
64490   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64491   {
64492     try {
64493       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64494     } catch (std::out_of_range& e) {
64495       {
64496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64497       };
64498     } catch (std::exception& e) {
64499       {
64500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64501       };
64502     } catch (Dali::DaliException e) {
64503       {
64504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64505       };
64506     } catch (...) {
64507       {
64508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64509       };
64510     }
64511   }
64512
64513 }
64514
64515
64516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64517   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64518   Dali::Vector3 *arg2 = 0 ;
64519   SwigDirector_ViewImpl *darg = 0;
64520
64521   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64522   arg2 = (Dali::Vector3 *)jarg2;
64523   if (!arg2) {
64524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64525     return ;
64526   }
64527   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64528   {
64529     try {
64530       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64531     } catch (std::out_of_range& e) {
64532       {
64533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64534       };
64535     } catch (std::exception& e) {
64536       {
64537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64538       };
64539     } catch (Dali::DaliException e) {
64540       {
64541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64542       };
64543     } catch (...) {
64544       {
64545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64546       };
64547     }
64548   }
64549
64550 }
64551
64552
64553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64554   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64555   Dali::Vector3 *arg2 = 0 ;
64556   SwigDirector_ViewImpl *darg = 0;
64557
64558   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64559   arg2 = (Dali::Vector3 *)jarg2;
64560   if (!arg2) {
64561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64562     return ;
64563   }
64564   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64565   {
64566     try {
64567       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64568     } catch (std::out_of_range& e) {
64569       {
64570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64571       };
64572     } catch (std::exception& e) {
64573       {
64574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64575       };
64576     } catch (Dali::DaliException e) {
64577       {
64578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64579       };
64580     } catch (...) {
64581       {
64582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64583       };
64584     }
64585   }
64586
64587 }
64588
64589
64590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64591   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64592   Dali::Animation *arg2 = 0 ;
64593   Dali::Vector3 *arg3 = 0 ;
64594   SwigDirector_ViewImpl *darg = 0;
64595
64596   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64597   arg2 = (Dali::Animation *)jarg2;
64598   if (!arg2) {
64599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64600     return ;
64601   }
64602   arg3 = (Dali::Vector3 *)jarg3;
64603   if (!arg3) {
64604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64605     return ;
64606   }
64607   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64608   {
64609     try {
64610       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64611     } catch (std::out_of_range& e) {
64612       {
64613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64614       };
64615     } catch (std::exception& e) {
64616       {
64617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64618       };
64619     } catch (Dali::DaliException e) {
64620       {
64621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64622       };
64623     } catch (...) {
64624       {
64625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64626       };
64627     }
64628   }
64629
64630 }
64631
64632
64633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64634   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64635   Dali::Animation *arg2 = 0 ;
64636   Dali::Vector3 *arg3 = 0 ;
64637   SwigDirector_ViewImpl *darg = 0;
64638
64639   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64640   arg2 = (Dali::Animation *)jarg2;
64641   if (!arg2) {
64642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64643     return ;
64644   }
64645   arg3 = (Dali::Vector3 *)jarg3;
64646   if (!arg3) {
64647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64648     return ;
64649   }
64650   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64651   {
64652     try {
64653       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64654     } catch (std::out_of_range& e) {
64655       {
64656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64657       };
64658     } catch (std::exception& e) {
64659       {
64660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64661       };
64662     } catch (Dali::DaliException e) {
64663       {
64664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64665       };
64666     } catch (...) {
64667       {
64668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64669       };
64670     }
64671   }
64672
64673 }
64674
64675
64676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64677   unsigned int jresult ;
64678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64679   Dali::TouchEvent *arg2 = 0 ;
64680   SwigDirector_ViewImpl *darg = 0;
64681   bool result;
64682
64683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64684   arg2 = (Dali::TouchEvent *)jarg2;
64685   if (!arg2) {
64686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64687     return 0;
64688   }
64689   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64690   {
64691     try {
64692       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64693     } catch (std::out_of_range& e) {
64694       {
64695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64696       };
64697     } catch (std::exception& e) {
64698       {
64699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64700       };
64701     } catch (Dali::DaliException e) {
64702       {
64703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64704       };
64705     } catch (...) {
64706       {
64707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64708       };
64709     }
64710   }
64711
64712   jresult = result;
64713   return jresult;
64714 }
64715
64716
64717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64718   unsigned int jresult ;
64719   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64720   Dali::TouchEvent *arg2 = 0 ;
64721   SwigDirector_ViewImpl *darg = 0;
64722   bool result;
64723
64724   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64725   arg2 = (Dali::TouchEvent *)jarg2;
64726   if (!arg2) {
64727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64728     return 0;
64729   }
64730   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64731   {
64732     try {
64733       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64734     } catch (std::out_of_range& e) {
64735       {
64736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64737       };
64738     } catch (std::exception& e) {
64739       {
64740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64741       };
64742     } catch (Dali::DaliException e) {
64743       {
64744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64745       };
64746     } catch (...) {
64747       {
64748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64749       };
64750     }
64751   }
64752
64753   jresult = result;
64754   return jresult;
64755 }
64756
64757
64758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64759   unsigned int jresult ;
64760   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64761   Dali::HoverEvent *arg2 = 0 ;
64762   SwigDirector_ViewImpl *darg = 0;
64763   bool result;
64764
64765   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64766   arg2 = (Dali::HoverEvent *)jarg2;
64767   if (!arg2) {
64768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64769     return 0;
64770   }
64771   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64772   {
64773     try {
64774       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64775     } catch (std::out_of_range& e) {
64776       {
64777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64778       };
64779     } catch (std::exception& e) {
64780       {
64781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64782       };
64783     } catch (Dali::DaliException e) {
64784       {
64785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64786       };
64787     } catch (...) {
64788       {
64789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64790       };
64791     }
64792   }
64793
64794   jresult = result;
64795   return jresult;
64796 }
64797
64798
64799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64800   unsigned int jresult ;
64801   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64802   Dali::HoverEvent *arg2 = 0 ;
64803   SwigDirector_ViewImpl *darg = 0;
64804   bool result;
64805
64806   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64807   arg2 = (Dali::HoverEvent *)jarg2;
64808   if (!arg2) {
64809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64810     return 0;
64811   }
64812   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64813   {
64814     try {
64815       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64816     } catch (std::out_of_range& e) {
64817       {
64818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64819       };
64820     } catch (std::exception& e) {
64821       {
64822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64823       };
64824     } catch (Dali::DaliException e) {
64825       {
64826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64827       };
64828     } catch (...) {
64829       {
64830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64831       };
64832     }
64833   }
64834
64835   jresult = result;
64836   return jresult;
64837 }
64838
64839
64840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64841   unsigned int jresult ;
64842   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64843   Dali::KeyEvent *arg2 = 0 ;
64844   SwigDirector_ViewImpl *darg = 0;
64845   bool result;
64846
64847   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64848   arg2 = (Dali::KeyEvent *)jarg2;
64849   if (!arg2) {
64850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64851     return 0;
64852   }
64853   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64854   {
64855     try {
64856       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64857     } catch (std::out_of_range& e) {
64858       {
64859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64860       };
64861     } catch (std::exception& e) {
64862       {
64863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64864       };
64865     } catch (Dali::DaliException e) {
64866       {
64867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64868       };
64869     } catch (...) {
64870       {
64871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64872       };
64873     }
64874   }
64875
64876   jresult = result;
64877   return jresult;
64878 }
64879
64880
64881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64882   unsigned int jresult ;
64883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64884   Dali::KeyEvent *arg2 = 0 ;
64885   SwigDirector_ViewImpl *darg = 0;
64886   bool result;
64887
64888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64889   arg2 = (Dali::KeyEvent *)jarg2;
64890   if (!arg2) {
64891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64892     return 0;
64893   }
64894   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64895   {
64896     try {
64897       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64898     } catch (std::out_of_range& e) {
64899       {
64900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64901       };
64902     } catch (std::exception& e) {
64903       {
64904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64905       };
64906     } catch (Dali::DaliException e) {
64907       {
64908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64909       };
64910     } catch (...) {
64911       {
64912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64913       };
64914     }
64915   }
64916
64917   jresult = result;
64918   return jresult;
64919 }
64920
64921
64922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64923   unsigned int jresult ;
64924   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64925   Dali::WheelEvent *arg2 = 0 ;
64926   SwigDirector_ViewImpl *darg = 0;
64927   bool result;
64928
64929   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64930   arg2 = (Dali::WheelEvent *)jarg2;
64931   if (!arg2) {
64932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64933     return 0;
64934   }
64935   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64936   {
64937     try {
64938       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64939     } catch (std::out_of_range& e) {
64940       {
64941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64942       };
64943     } catch (std::exception& e) {
64944       {
64945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64946       };
64947     } catch (Dali::DaliException e) {
64948       {
64949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64950       };
64951     } catch (...) {
64952       {
64953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64954       };
64955     }
64956   }
64957
64958   jresult = result;
64959   return jresult;
64960 }
64961
64962
64963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64964   unsigned int jresult ;
64965   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64966   Dali::WheelEvent *arg2 = 0 ;
64967   SwigDirector_ViewImpl *darg = 0;
64968   bool result;
64969
64970   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64971   arg2 = (Dali::WheelEvent *)jarg2;
64972   if (!arg2) {
64973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64974     return 0;
64975   }
64976   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64977   {
64978     try {
64979       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64980     } catch (std::out_of_range& e) {
64981       {
64982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64983       };
64984     } catch (std::exception& e) {
64985       {
64986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64987       };
64988     } catch (Dali::DaliException e) {
64989       {
64990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64991       };
64992     } catch (...) {
64993       {
64994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64995       };
64996     }
64997   }
64998
64999   jresult = result;
65000   return jresult;
65001 }
65002
65003
65004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65005   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65006   Dali::Vector2 *arg2 = 0 ;
65007   Dali::RelayoutContainer *arg3 = 0 ;
65008   SwigDirector_ViewImpl *darg = 0;
65009
65010   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65011   arg2 = (Dali::Vector2 *)jarg2;
65012   if (!arg2) {
65013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65014     return ;
65015   }
65016   arg3 = (Dali::RelayoutContainer *)jarg3;
65017   if (!arg3) {
65018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65019     return ;
65020   }
65021   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65022   {
65023     try {
65024       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65025     } catch (std::out_of_range& e) {
65026       {
65027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65028       };
65029     } catch (std::exception& e) {
65030       {
65031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65032       };
65033     } catch (Dali::DaliException e) {
65034       {
65035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65036       };
65037     } catch (...) {
65038       {
65039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65040       };
65041     }
65042   }
65043
65044 }
65045
65046
65047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65048   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65049   Dali::Vector2 *arg2 = 0 ;
65050   Dali::RelayoutContainer *arg3 = 0 ;
65051   SwigDirector_ViewImpl *darg = 0;
65052
65053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65054   arg2 = (Dali::Vector2 *)jarg2;
65055   if (!arg2) {
65056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65057     return ;
65058   }
65059   arg3 = (Dali::RelayoutContainer *)jarg3;
65060   if (!arg3) {
65061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65062     return ;
65063   }
65064   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65065   {
65066     try {
65067       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65068     } catch (std::out_of_range& e) {
65069       {
65070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65071       };
65072     } catch (std::exception& e) {
65073       {
65074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65075       };
65076     } catch (Dali::DaliException e) {
65077       {
65078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65079       };
65080     } catch (...) {
65081       {
65082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65083       };
65084     }
65085   }
65086
65087 }
65088
65089
65090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65091   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65092   Dali::ResizePolicy::Type arg2 ;
65093   Dali::Dimension::Type arg3 ;
65094   SwigDirector_ViewImpl *darg = 0;
65095
65096   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65097   arg2 = (Dali::ResizePolicy::Type)jarg2;
65098   arg3 = (Dali::Dimension::Type)jarg3;
65099   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65100   {
65101     try {
65102       (darg)->OnSetResizePolicy(arg2,arg3);
65103     } catch (std::out_of_range& e) {
65104       {
65105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65106       };
65107     } catch (std::exception& e) {
65108       {
65109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65110       };
65111     } catch (Dali::DaliException e) {
65112       {
65113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65114       };
65115     } catch (...) {
65116       {
65117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65118       };
65119     }
65120   }
65121
65122 }
65123
65124
65125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65126   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65127   Dali::ResizePolicy::Type arg2 ;
65128   Dali::Dimension::Type arg3 ;
65129   SwigDirector_ViewImpl *darg = 0;
65130
65131   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65132   arg2 = (Dali::ResizePolicy::Type)jarg2;
65133   arg3 = (Dali::Dimension::Type)jarg3;
65134   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65135   {
65136     try {
65137       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65138     } catch (std::out_of_range& e) {
65139       {
65140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65141       };
65142     } catch (std::exception& e) {
65143       {
65144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65145       };
65146     } catch (Dali::DaliException e) {
65147       {
65148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65149       };
65150     } catch (...) {
65151       {
65152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65153       };
65154     }
65155   }
65156
65157 }
65158
65159
65160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65161   void * jresult ;
65162   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65163   SwigDirector_ViewImpl *darg = 0;
65164   Dali::Vector3 result;
65165
65166   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65167   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65168   {
65169     try {
65170       result = (darg)->GetNaturalSize();
65171     } catch (std::out_of_range& e) {
65172       {
65173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65174       };
65175     } catch (std::exception& e) {
65176       {
65177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65178       };
65179     } catch (Dali::DaliException e) {
65180       {
65181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65182       };
65183     } catch (...) {
65184       {
65185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65186       };
65187     }
65188   }
65189
65190   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65191   return jresult;
65192 }
65193
65194
65195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65196   void * jresult ;
65197   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65198   SwigDirector_ViewImpl *darg = 0;
65199   Dali::Vector3 result;
65200
65201   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65202   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65203   {
65204     try {
65205       result = (darg)->GetNaturalSizeSwigPublic();
65206     } catch (std::out_of_range& e) {
65207       {
65208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65209       };
65210     } catch (std::exception& e) {
65211       {
65212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65213       };
65214     } catch (Dali::DaliException e) {
65215       {
65216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65217       };
65218     } catch (...) {
65219       {
65220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65221       };
65222     }
65223   }
65224
65225   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65226   return jresult;
65227 }
65228
65229
65230 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65231   float jresult ;
65232   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65233   Dali::Actor *arg2 = 0 ;
65234   Dali::Dimension::Type arg3 ;
65235   SwigDirector_ViewImpl *darg = 0;
65236   float result;
65237
65238   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65239   arg2 = (Dali::Actor *)jarg2;
65240   if (!arg2) {
65241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65242     return 0;
65243   }
65244   arg3 = (Dali::Dimension::Type)jarg3;
65245   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65246   {
65247     try {
65248       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65249     } catch (std::out_of_range& e) {
65250       {
65251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65252       };
65253     } catch (std::exception& e) {
65254       {
65255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65256       };
65257     } catch (Dali::DaliException e) {
65258       {
65259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65260       };
65261     } catch (...) {
65262       {
65263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65264       };
65265     }
65266   }
65267
65268   jresult = result;
65269   return jresult;
65270 }
65271
65272
65273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65274   float jresult ;
65275   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65276   Dali::Actor *arg2 = 0 ;
65277   Dali::Dimension::Type arg3 ;
65278   SwigDirector_ViewImpl *darg = 0;
65279   float result;
65280
65281   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65282   arg2 = (Dali::Actor *)jarg2;
65283   if (!arg2) {
65284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65285     return 0;
65286   }
65287   arg3 = (Dali::Dimension::Type)jarg3;
65288   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65289   {
65290     try {
65291       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65292     } catch (std::out_of_range& e) {
65293       {
65294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65295       };
65296     } catch (std::exception& e) {
65297       {
65298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65299       };
65300     } catch (Dali::DaliException e) {
65301       {
65302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65303       };
65304     } catch (...) {
65305       {
65306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65307       };
65308     }
65309   }
65310
65311   jresult = result;
65312   return jresult;
65313 }
65314
65315
65316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65317   float jresult ;
65318   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65319   float arg2 ;
65320   SwigDirector_ViewImpl *darg = 0;
65321   float result;
65322
65323   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65324   arg2 = (float)jarg2;
65325   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65326   {
65327     try {
65328       result = (float)(darg)->GetHeightForWidth(arg2);
65329     } catch (std::out_of_range& e) {
65330       {
65331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65332       };
65333     } catch (std::exception& e) {
65334       {
65335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65336       };
65337     } catch (Dali::DaliException e) {
65338       {
65339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65340       };
65341     } catch (...) {
65342       {
65343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65344       };
65345     }
65346   }
65347
65348   jresult = result;
65349   return jresult;
65350 }
65351
65352
65353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65354   float jresult ;
65355   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65356   float arg2 ;
65357   SwigDirector_ViewImpl *darg = 0;
65358   float result;
65359
65360   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65361   arg2 = (float)jarg2;
65362   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65363   {
65364     try {
65365       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65366     } catch (std::out_of_range& e) {
65367       {
65368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65369       };
65370     } catch (std::exception& e) {
65371       {
65372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65373       };
65374     } catch (Dali::DaliException e) {
65375       {
65376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65377       };
65378     } catch (...) {
65379       {
65380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65381       };
65382     }
65383   }
65384
65385   jresult = result;
65386   return jresult;
65387 }
65388
65389
65390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65391   float jresult ;
65392   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65393   float arg2 ;
65394   SwigDirector_ViewImpl *darg = 0;
65395   float result;
65396
65397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65398   arg2 = (float)jarg2;
65399   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65400   {
65401     try {
65402       result = (float)(darg)->GetWidthForHeight(arg2);
65403     } catch (std::out_of_range& e) {
65404       {
65405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65406       };
65407     } catch (std::exception& e) {
65408       {
65409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65410       };
65411     } catch (Dali::DaliException e) {
65412       {
65413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65414       };
65415     } catch (...) {
65416       {
65417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65418       };
65419     }
65420   }
65421
65422   jresult = result;
65423   return jresult;
65424 }
65425
65426
65427 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65428   float jresult ;
65429   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65430   float arg2 ;
65431   SwigDirector_ViewImpl *darg = 0;
65432   float result;
65433
65434   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65435   arg2 = (float)jarg2;
65436   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65437   {
65438     try {
65439       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65440     } catch (std::out_of_range& e) {
65441       {
65442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65443       };
65444     } catch (std::exception& e) {
65445       {
65446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65447       };
65448     } catch (Dali::DaliException e) {
65449       {
65450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65451       };
65452     } catch (...) {
65453       {
65454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65455       };
65456     }
65457   }
65458
65459   jresult = result;
65460   return jresult;
65461 }
65462
65463
65464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65465   unsigned int jresult ;
65466   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65467   Dali::Dimension::Type arg2 ;
65468   SwigDirector_ViewImpl *darg = 0;
65469   bool result;
65470
65471   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65472   arg2 = (Dali::Dimension::Type)jarg2;
65473   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65474   {
65475     try {
65476       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65477     } catch (std::out_of_range& e) {
65478       {
65479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65480       };
65481     } catch (std::exception& e) {
65482       {
65483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65484       };
65485     } catch (Dali::DaliException e) {
65486       {
65487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65488       };
65489     } catch (...) {
65490       {
65491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65492       };
65493     }
65494   }
65495
65496   jresult = result;
65497   return jresult;
65498 }
65499
65500
65501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65502   unsigned int jresult ;
65503   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65504   Dali::Dimension::Type arg2 ;
65505   SwigDirector_ViewImpl *darg = 0;
65506   bool result;
65507
65508   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65509   arg2 = (Dali::Dimension::Type)jarg2;
65510   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65511   {
65512     try {
65513       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65514     } catch (std::out_of_range& e) {
65515       {
65516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65517       };
65518     } catch (std::exception& e) {
65519       {
65520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65521       };
65522     } catch (Dali::DaliException e) {
65523       {
65524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65525       };
65526     } catch (...) {
65527       {
65528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65529       };
65530     }
65531   }
65532
65533   jresult = result;
65534   return jresult;
65535 }
65536
65537
65538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65539   unsigned int jresult ;
65540   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65541   SwigDirector_ViewImpl *darg = 0;
65542   bool result;
65543
65544   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65545   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65546   {
65547     try {
65548       result = (bool)(darg)->RelayoutDependentOnChildren();
65549     } catch (std::out_of_range& e) {
65550       {
65551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65552       };
65553     } catch (std::exception& e) {
65554       {
65555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65556       };
65557     } catch (Dali::DaliException e) {
65558       {
65559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65560       };
65561     } catch (...) {
65562       {
65563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65564       };
65565     }
65566   }
65567
65568   jresult = result;
65569   return jresult;
65570 }
65571
65572
65573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65574   unsigned int jresult ;
65575   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65576   SwigDirector_ViewImpl *darg = 0;
65577   bool result;
65578
65579   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65580   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65581   {
65582     try {
65583       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65584     } catch (std::out_of_range& e) {
65585       {
65586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65587       };
65588     } catch (std::exception& e) {
65589       {
65590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65591       };
65592     } catch (Dali::DaliException e) {
65593       {
65594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65595       };
65596     } catch (...) {
65597       {
65598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65599       };
65600     }
65601   }
65602
65603   jresult = result;
65604   return jresult;
65605 }
65606
65607
65608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65609   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65610   Dali::Dimension::Type arg2 ;
65611   SwigDirector_ViewImpl *darg = 0;
65612
65613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65614   arg2 = (Dali::Dimension::Type)jarg2;
65615   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65616   {
65617     try {
65618       (darg)->OnCalculateRelayoutSize(arg2);
65619     } catch (std::out_of_range& e) {
65620       {
65621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65622       };
65623     } catch (std::exception& e) {
65624       {
65625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65626       };
65627     } catch (Dali::DaliException e) {
65628       {
65629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65630       };
65631     } catch (...) {
65632       {
65633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65634       };
65635     }
65636   }
65637
65638 }
65639
65640
65641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65642   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65643   Dali::Dimension::Type arg2 ;
65644   SwigDirector_ViewImpl *darg = 0;
65645
65646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65647   arg2 = (Dali::Dimension::Type)jarg2;
65648   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65649   {
65650     try {
65651       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65652     } catch (std::out_of_range& e) {
65653       {
65654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65655       };
65656     } catch (std::exception& e) {
65657       {
65658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65659       };
65660     } catch (Dali::DaliException e) {
65661       {
65662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65663       };
65664     } catch (...) {
65665       {
65666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65667       };
65668     }
65669   }
65670
65671 }
65672
65673
65674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65675   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65676   float arg2 ;
65677   Dali::Dimension::Type arg3 ;
65678   SwigDirector_ViewImpl *darg = 0;
65679
65680   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65681   arg2 = (float)jarg2;
65682   arg3 = (Dali::Dimension::Type)jarg3;
65683   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65684   {
65685     try {
65686       (darg)->OnLayoutNegotiated(arg2,arg3);
65687     } catch (std::out_of_range& e) {
65688       {
65689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65690       };
65691     } catch (std::exception& e) {
65692       {
65693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65694       };
65695     } catch (Dali::DaliException e) {
65696       {
65697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65698       };
65699     } catch (...) {
65700       {
65701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65702       };
65703     }
65704   }
65705
65706 }
65707
65708
65709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65710   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65711   float arg2 ;
65712   Dali::Dimension::Type arg3 ;
65713   SwigDirector_ViewImpl *darg = 0;
65714
65715   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65716   arg2 = (float)jarg2;
65717   arg3 = (Dali::Dimension::Type)jarg3;
65718   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65719   {
65720     try {
65721       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65722     } catch (std::out_of_range& e) {
65723       {
65724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65725       };
65726     } catch (std::exception& e) {
65727       {
65728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65729       };
65730     } catch (Dali::DaliException e) {
65731       {
65732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65733       };
65734     } catch (...) {
65735       {
65736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65737       };
65738     }
65739   }
65740
65741 }
65742
65743
65744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65746
65747   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65748   {
65749     try {
65750       (arg1)->OnInitialize();
65751     } catch (std::out_of_range& e) {
65752       {
65753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65754       };
65755     } catch (std::exception& e) {
65756       {
65757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65758       };
65759     } catch (Dali::DaliException e) {
65760       {
65761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65762       };
65763     } catch (...) {
65764       {
65765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65766       };
65767     }
65768   }
65769
65770 }
65771
65772
65773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65775
65776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65777   {
65778     try {
65779       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65780     } catch (std::out_of_range& e) {
65781       {
65782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65783       };
65784     } catch (std::exception& e) {
65785       {
65786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65787       };
65788     } catch (Dali::DaliException e) {
65789       {
65790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65791       };
65792     } catch (...) {
65793       {
65794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65795       };
65796     }
65797   }
65798
65799 }
65800
65801
65802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65803   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65804   Dali::Actor *arg2 = 0 ;
65805
65806   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65807   arg2 = (Dali::Actor *)jarg2;
65808   if (!arg2) {
65809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65810     return ;
65811   }
65812   {
65813     try {
65814       (arg1)->OnControlChildAdd(*arg2);
65815     } catch (std::out_of_range& e) {
65816       {
65817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65818       };
65819     } catch (std::exception& e) {
65820       {
65821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65822       };
65823     } catch (Dali::DaliException e) {
65824       {
65825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65826       };
65827     } catch (...) {
65828       {
65829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65830       };
65831     }
65832   }
65833
65834 }
65835
65836
65837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65838   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65839   Dali::Actor *arg2 = 0 ;
65840
65841   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65842   arg2 = (Dali::Actor *)jarg2;
65843   if (!arg2) {
65844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65845     return ;
65846   }
65847   {
65848     try {
65849       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65850     } catch (std::out_of_range& e) {
65851       {
65852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65853       };
65854     } catch (std::exception& e) {
65855       {
65856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65857       };
65858     } catch (Dali::DaliException e) {
65859       {
65860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65861       };
65862     } catch (...) {
65863       {
65864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65865       };
65866     }
65867   }
65868
65869 }
65870
65871
65872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65873   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65874   Dali::Actor *arg2 = 0 ;
65875
65876   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65877   arg2 = (Dali::Actor *)jarg2;
65878   if (!arg2) {
65879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65880     return ;
65881   }
65882   {
65883     try {
65884       (arg1)->OnControlChildRemove(*arg2);
65885     } catch (std::out_of_range& e) {
65886       {
65887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65888       };
65889     } catch (std::exception& e) {
65890       {
65891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65892       };
65893     } catch (Dali::DaliException e) {
65894       {
65895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65896       };
65897     } catch (...) {
65898       {
65899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65900       };
65901     }
65902   }
65903
65904 }
65905
65906
65907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65908   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65909   Dali::Actor *arg2 = 0 ;
65910
65911   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65912   arg2 = (Dali::Actor *)jarg2;
65913   if (!arg2) {
65914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65915     return ;
65916   }
65917   {
65918     try {
65919       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65920     } catch (std::out_of_range& e) {
65921       {
65922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65923       };
65924     } catch (std::exception& e) {
65925       {
65926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65927       };
65928     } catch (Dali::DaliException e) {
65929       {
65930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65931       };
65932     } catch (...) {
65933       {
65934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65935       };
65936     }
65937   }
65938
65939 }
65940
65941
65942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65943   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65944   Dali::Toolkit::StyleManager arg2 ;
65945   Dali::StyleChange::Type arg3 ;
65946   Dali::Toolkit::StyleManager *argp2 ;
65947
65948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65949   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65950   if (!argp2) {
65951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65952     return ;
65953   }
65954   arg2 = *argp2;
65955   arg3 = (Dali::StyleChange::Type)jarg3;
65956   {
65957     try {
65958       (arg1)->OnStyleChange(arg2,arg3);
65959     } catch (std::out_of_range& e) {
65960       {
65961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65962       };
65963     } catch (std::exception& e) {
65964       {
65965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65966       };
65967     } catch (Dali::DaliException e) {
65968       {
65969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65970       };
65971     } catch (...) {
65972       {
65973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65974       };
65975     }
65976   }
65977
65978 }
65979
65980
65981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65982   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65983   Dali::Toolkit::StyleManager arg2 ;
65984   Dali::StyleChange::Type arg3 ;
65985   Dali::Toolkit::StyleManager *argp2 ;
65986
65987   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65988   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65989   if (!argp2) {
65990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65991     return ;
65992   }
65993   arg2 = *argp2;
65994   arg3 = (Dali::StyleChange::Type)jarg3;
65995   {
65996     try {
65997       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65998     } catch (std::out_of_range& e) {
65999       {
66000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66001       };
66002     } catch (std::exception& e) {
66003       {
66004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66005       };
66006     } catch (Dali::DaliException e) {
66007       {
66008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66009       };
66010     } catch (...) {
66011       {
66012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66013       };
66014     }
66015   }
66016
66017 }
66018
66019
66020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66021   unsigned int jresult ;
66022   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66023   bool result;
66024
66025   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66026   {
66027     try {
66028       result = (bool)(arg1)->OnAccessibilityActivated();
66029     } catch (std::out_of_range& e) {
66030       {
66031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66032       };
66033     } catch (std::exception& e) {
66034       {
66035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66036       };
66037     } catch (Dali::DaliException e) {
66038       {
66039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66040       };
66041     } catch (...) {
66042       {
66043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66044       };
66045     }
66046   }
66047
66048   jresult = result;
66049   return jresult;
66050 }
66051
66052
66053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66054   unsigned int jresult ;
66055   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66056   bool result;
66057
66058   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66059   {
66060     try {
66061       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66062     } catch (std::out_of_range& e) {
66063       {
66064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66065       };
66066     } catch (std::exception& e) {
66067       {
66068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66069       };
66070     } catch (Dali::DaliException e) {
66071       {
66072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66073       };
66074     } catch (...) {
66075       {
66076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66077       };
66078     }
66079   }
66080
66081   jresult = result;
66082   return jresult;
66083 }
66084
66085
66086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66087   unsigned int jresult ;
66088   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66089   Dali::PanGesture arg2 ;
66090   Dali::PanGesture *argp2 ;
66091   bool result;
66092
66093   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66094   argp2 = (Dali::PanGesture *)jarg2;
66095   if (!argp2) {
66096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66097     return 0;
66098   }
66099   arg2 = *argp2;
66100   {
66101     try {
66102       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66103     } catch (std::out_of_range& e) {
66104       {
66105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66106       };
66107     } catch (std::exception& e) {
66108       {
66109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66110       };
66111     } catch (Dali::DaliException e) {
66112       {
66113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66114       };
66115     } catch (...) {
66116       {
66117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66118       };
66119     }
66120   }
66121
66122   jresult = result;
66123   return jresult;
66124 }
66125
66126
66127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66128   unsigned int jresult ;
66129   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66130   Dali::PanGesture arg2 ;
66131   Dali::PanGesture *argp2 ;
66132   bool result;
66133
66134   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66135   argp2 = (Dali::PanGesture *)jarg2;
66136   if (!argp2) {
66137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66138     return 0;
66139   }
66140   arg2 = *argp2;
66141   {
66142     try {
66143       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66144     } catch (std::out_of_range& e) {
66145       {
66146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66147       };
66148     } catch (std::exception& e) {
66149       {
66150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66151       };
66152     } catch (Dali::DaliException e) {
66153       {
66154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66155       };
66156     } catch (...) {
66157       {
66158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66159       };
66160     }
66161   }
66162
66163   jresult = result;
66164   return jresult;
66165 }
66166
66167
66168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66169   unsigned int jresult ;
66170   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66171   Dali::TouchEvent *arg2 = 0 ;
66172   bool result;
66173
66174   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66175   arg2 = (Dali::TouchEvent *)jarg2;
66176   if (!arg2) {
66177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66178     return 0;
66179   }
66180   {
66181     try {
66182       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66183     } catch (std::out_of_range& e) {
66184       {
66185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66186       };
66187     } catch (std::exception& e) {
66188       {
66189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66190       };
66191     } catch (Dali::DaliException e) {
66192       {
66193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66194       };
66195     } catch (...) {
66196       {
66197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66198       };
66199     }
66200   }
66201
66202   jresult = result;
66203   return jresult;
66204 }
66205
66206
66207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66208   unsigned int jresult ;
66209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66210   Dali::TouchEvent *arg2 = 0 ;
66211   bool result;
66212
66213   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66214   arg2 = (Dali::TouchEvent *)jarg2;
66215   if (!arg2) {
66216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66217     return 0;
66218   }
66219   {
66220     try {
66221       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66222     } catch (std::out_of_range& e) {
66223       {
66224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66225       };
66226     } catch (std::exception& e) {
66227       {
66228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66229       };
66230     } catch (Dali::DaliException e) {
66231       {
66232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66233       };
66234     } catch (...) {
66235       {
66236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66237       };
66238     }
66239   }
66240
66241   jresult = result;
66242   return jresult;
66243 }
66244
66245
66246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66247   unsigned int jresult ;
66248   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66249   bool arg2 ;
66250   bool result;
66251
66252   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66253   arg2 = jarg2 ? true : false;
66254   {
66255     try {
66256       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66257     } catch (std::out_of_range& e) {
66258       {
66259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66260       };
66261     } catch (std::exception& e) {
66262       {
66263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66264       };
66265     } catch (Dali::DaliException e) {
66266       {
66267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66268       };
66269     } catch (...) {
66270       {
66271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66272       };
66273     }
66274   }
66275
66276   jresult = result;
66277   return jresult;
66278 }
66279
66280
66281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66282   unsigned int jresult ;
66283   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66284   bool arg2 ;
66285   bool result;
66286
66287   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66288   arg2 = jarg2 ? true : false;
66289   {
66290     try {
66291       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66292     } catch (std::out_of_range& e) {
66293       {
66294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66295       };
66296     } catch (std::exception& e) {
66297       {
66298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66299       };
66300     } catch (Dali::DaliException e) {
66301       {
66302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66303       };
66304     } catch (...) {
66305       {
66306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66307       };
66308     }
66309   }
66310
66311   jresult = result;
66312   return jresult;
66313 }
66314
66315
66316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66317   unsigned int jresult ;
66318   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66319   bool result;
66320
66321   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66322   {
66323     try {
66324       result = (bool)(arg1)->OnAccessibilityZoom();
66325     } catch (std::out_of_range& e) {
66326       {
66327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66328       };
66329     } catch (std::exception& e) {
66330       {
66331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66332       };
66333     } catch (Dali::DaliException e) {
66334       {
66335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66336       };
66337     } catch (...) {
66338       {
66339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66340       };
66341     }
66342   }
66343
66344   jresult = result;
66345   return jresult;
66346 }
66347
66348
66349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66350   unsigned int jresult ;
66351   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66352   bool result;
66353
66354   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66355   {
66356     try {
66357       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66358     } catch (std::out_of_range& e) {
66359       {
66360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66361       };
66362     } catch (std::exception& e) {
66363       {
66364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66365       };
66366     } catch (Dali::DaliException e) {
66367       {
66368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66369       };
66370     } catch (...) {
66371       {
66372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66373       };
66374     }
66375   }
66376
66377   jresult = result;
66378   return jresult;
66379 }
66380
66381
66382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66383   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66384
66385   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66386   {
66387     try {
66388       (arg1)->OnKeyInputFocusGained();
66389     } catch (std::out_of_range& e) {
66390       {
66391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66392       };
66393     } catch (std::exception& e) {
66394       {
66395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66396       };
66397     } catch (Dali::DaliException e) {
66398       {
66399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66400       };
66401     } catch (...) {
66402       {
66403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66404       };
66405     }
66406   }
66407
66408 }
66409
66410
66411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66412   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66413
66414   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66415   {
66416     try {
66417       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66418     } catch (std::out_of_range& e) {
66419       {
66420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66421       };
66422     } catch (std::exception& e) {
66423       {
66424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66425       };
66426     } catch (Dali::DaliException e) {
66427       {
66428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66429       };
66430     } catch (...) {
66431       {
66432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66433       };
66434     }
66435   }
66436
66437 }
66438
66439
66440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66441   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66442
66443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66444   {
66445     try {
66446       (arg1)->OnKeyInputFocusLost();
66447     } catch (std::out_of_range& e) {
66448       {
66449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66450       };
66451     } catch (std::exception& e) {
66452       {
66453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66454       };
66455     } catch (Dali::DaliException e) {
66456       {
66457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66458       };
66459     } catch (...) {
66460       {
66461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66462       };
66463     }
66464   }
66465
66466 }
66467
66468
66469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66470   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66471
66472   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66473   {
66474     try {
66475       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66476     } catch (std::out_of_range& e) {
66477       {
66478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66479       };
66480     } catch (std::exception& e) {
66481       {
66482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66483       };
66484     } catch (Dali::DaliException e) {
66485       {
66486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66487       };
66488     } catch (...) {
66489       {
66490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66491       };
66492     }
66493   }
66494
66495 }
66496
66497
66498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66499   void * jresult ;
66500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66501   Dali::Actor arg2 ;
66502   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66503   bool arg4 ;
66504   Dali::Actor *argp2 ;
66505   Dali::Actor result;
66506
66507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66508   argp2 = (Dali::Actor *)jarg2;
66509   if (!argp2) {
66510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66511     return 0;
66512   }
66513   arg2 = *argp2;
66514   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66515   arg4 = jarg4 ? true : false;
66516   {
66517     try {
66518       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66519     } catch (std::out_of_range& e) {
66520       {
66521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66522       };
66523     } catch (std::exception& e) {
66524       {
66525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66526       };
66527     } catch (Dali::DaliException e) {
66528       {
66529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66530       };
66531     } catch (...) {
66532       {
66533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66534       };
66535     }
66536   }
66537
66538   jresult = new Dali::Actor((const Dali::Actor &)result);
66539   return jresult;
66540 }
66541
66542
66543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66544   void * jresult ;
66545   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66546   Dali::Actor arg2 ;
66547   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66548   bool arg4 ;
66549   Dali::Actor *argp2 ;
66550   Dali::Actor result;
66551
66552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66553   argp2 = (Dali::Actor *)jarg2;
66554   if (!argp2) {
66555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66556     return 0;
66557   }
66558   arg2 = *argp2;
66559   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66560   arg4 = jarg4 ? true : false;
66561   {
66562     try {
66563       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66564     } catch (std::out_of_range& e) {
66565       {
66566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66567       };
66568     } catch (std::exception& e) {
66569       {
66570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66571       };
66572     } catch (Dali::DaliException e) {
66573       {
66574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66575       };
66576     } catch (...) {
66577       {
66578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66579       };
66580     }
66581   }
66582
66583   jresult = new Dali::Actor((const Dali::Actor &)result);
66584   return jresult;
66585 }
66586
66587
66588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66589   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66590   Dali::Actor arg2 ;
66591   Dali::Actor *argp2 ;
66592
66593   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66594   argp2 = (Dali::Actor *)jarg2;
66595   if (!argp2) {
66596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66597     return ;
66598   }
66599   arg2 = *argp2;
66600   {
66601     try {
66602       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66603     } catch (std::out_of_range& e) {
66604       {
66605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66606       };
66607     } catch (std::exception& e) {
66608       {
66609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66610       };
66611     } catch (Dali::DaliException e) {
66612       {
66613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66614       };
66615     } catch (...) {
66616       {
66617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66618       };
66619     }
66620   }
66621
66622 }
66623
66624
66625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66626   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66627   Dali::Actor arg2 ;
66628   Dali::Actor *argp2 ;
66629
66630   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66631   argp2 = (Dali::Actor *)jarg2;
66632   if (!argp2) {
66633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66634     return ;
66635   }
66636   arg2 = *argp2;
66637   {
66638     try {
66639       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66640     } catch (std::out_of_range& e) {
66641       {
66642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66643       };
66644     } catch (std::exception& e) {
66645       {
66646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66647       };
66648     } catch (Dali::DaliException e) {
66649       {
66650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66651       };
66652     } catch (...) {
66653       {
66654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66655       };
66656     }
66657   }
66658
66659 }
66660
66661
66662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66663   unsigned int jresult ;
66664   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66665   bool result;
66666
66667   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66668   {
66669     try {
66670       result = (bool)(arg1)->OnKeyboardEnter();
66671     } catch (std::out_of_range& e) {
66672       {
66673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66674       };
66675     } catch (std::exception& e) {
66676       {
66677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66678       };
66679     } catch (Dali::DaliException e) {
66680       {
66681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66682       };
66683     } catch (...) {
66684       {
66685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66686       };
66687     }
66688   }
66689
66690   jresult = result;
66691   return jresult;
66692 }
66693
66694
66695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66696   unsigned int jresult ;
66697   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66698   bool result;
66699
66700   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66701   {
66702     try {
66703       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66704     } catch (std::out_of_range& e) {
66705       {
66706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66707       };
66708     } catch (std::exception& e) {
66709       {
66710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66711       };
66712     } catch (Dali::DaliException e) {
66713       {
66714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66715       };
66716     } catch (...) {
66717       {
66718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66719       };
66720     }
66721   }
66722
66723   jresult = result;
66724   return jresult;
66725 }
66726
66727
66728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66729   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66730   Dali::PinchGesture *arg2 = 0 ;
66731
66732   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66733   arg2 = (Dali::PinchGesture *)jarg2;
66734   if (!arg2) {
66735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66736     return ;
66737   }
66738   {
66739     try {
66740       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66741     } catch (std::out_of_range& e) {
66742       {
66743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66744       };
66745     } catch (std::exception& e) {
66746       {
66747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66748       };
66749     } catch (Dali::DaliException e) {
66750       {
66751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66752       };
66753     } catch (...) {
66754       {
66755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66756       };
66757     }
66758   }
66759
66760 }
66761
66762
66763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66764   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66765   Dali::PinchGesture *arg2 = 0 ;
66766
66767   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66768   arg2 = (Dali::PinchGesture *)jarg2;
66769   if (!arg2) {
66770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66771     return ;
66772   }
66773   {
66774     try {
66775       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66776     } catch (std::out_of_range& e) {
66777       {
66778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66779       };
66780     } catch (std::exception& e) {
66781       {
66782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66783       };
66784     } catch (Dali::DaliException e) {
66785       {
66786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66787       };
66788     } catch (...) {
66789       {
66790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66791       };
66792     }
66793   }
66794
66795 }
66796
66797
66798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66800   Dali::PanGesture *arg2 = 0 ;
66801
66802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66803   arg2 = (Dali::PanGesture *)jarg2;
66804   if (!arg2) {
66805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66806     return ;
66807   }
66808   {
66809     try {
66810       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66811     } catch (std::out_of_range& e) {
66812       {
66813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66814       };
66815     } catch (std::exception& e) {
66816       {
66817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66818       };
66819     } catch (Dali::DaliException e) {
66820       {
66821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66822       };
66823     } catch (...) {
66824       {
66825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66826       };
66827     }
66828   }
66829
66830 }
66831
66832
66833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66834   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66835   Dali::PanGesture *arg2 = 0 ;
66836
66837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66838   arg2 = (Dali::PanGesture *)jarg2;
66839   if (!arg2) {
66840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66841     return ;
66842   }
66843   {
66844     try {
66845       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66846     } catch (std::out_of_range& e) {
66847       {
66848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66849       };
66850     } catch (std::exception& e) {
66851       {
66852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66853       };
66854     } catch (Dali::DaliException e) {
66855       {
66856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66857       };
66858     } catch (...) {
66859       {
66860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66861       };
66862     }
66863   }
66864
66865 }
66866
66867
66868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66869   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66870   Dali::TapGesture *arg2 = 0 ;
66871
66872   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66873   arg2 = (Dali::TapGesture *)jarg2;
66874   if (!arg2) {
66875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66876     return ;
66877   }
66878   {
66879     try {
66880       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66881     } catch (std::out_of_range& e) {
66882       {
66883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66884       };
66885     } catch (std::exception& e) {
66886       {
66887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66888       };
66889     } catch (Dali::DaliException e) {
66890       {
66891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66892       };
66893     } catch (...) {
66894       {
66895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66896       };
66897     }
66898   }
66899
66900 }
66901
66902
66903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66904   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66905   Dali::TapGesture *arg2 = 0 ;
66906
66907   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66908   arg2 = (Dali::TapGesture *)jarg2;
66909   if (!arg2) {
66910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66911     return ;
66912   }
66913   {
66914     try {
66915       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66916     } catch (std::out_of_range& e) {
66917       {
66918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66919       };
66920     } catch (std::exception& e) {
66921       {
66922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66923       };
66924     } catch (Dali::DaliException e) {
66925       {
66926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66927       };
66928     } catch (...) {
66929       {
66930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66931       };
66932     }
66933   }
66934
66935 }
66936
66937
66938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66939   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66940   Dali::LongPressGesture *arg2 = 0 ;
66941
66942   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66943   arg2 = (Dali::LongPressGesture *)jarg2;
66944   if (!arg2) {
66945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66946     return ;
66947   }
66948   {
66949     try {
66950       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66951     } catch (std::out_of_range& e) {
66952       {
66953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66954       };
66955     } catch (std::exception& e) {
66956       {
66957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66958       };
66959     } catch (Dali::DaliException e) {
66960       {
66961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66962       };
66963     } catch (...) {
66964       {
66965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66966       };
66967     }
66968   }
66969
66970 }
66971
66972
66973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66974   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66975   Dali::LongPressGesture *arg2 = 0 ;
66976
66977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66978   arg2 = (Dali::LongPressGesture *)jarg2;
66979   if (!arg2) {
66980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66981     return ;
66982   }
66983   {
66984     try {
66985       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66986     } catch (std::out_of_range& e) {
66987       {
66988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66989       };
66990     } catch (std::exception& e) {
66991       {
66992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66993       };
66994     } catch (Dali::DaliException e) {
66995       {
66996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66997       };
66998     } catch (...) {
66999       {
67000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67001       };
67002     }
67003   }
67004
67005 }
67006
67007
67008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67009   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67010   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67011   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67012
67013   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67014   arg2 = (Dali::SlotObserver *)jarg2;
67015   arg3 = (Dali::CallbackBase *)jarg3;
67016   {
67017     try {
67018       (arg1)->SignalConnected(arg2,arg3);
67019     } catch (std::out_of_range& e) {
67020       {
67021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67022       };
67023     } catch (std::exception& e) {
67024       {
67025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67026       };
67027     } catch (Dali::DaliException e) {
67028       {
67029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67030       };
67031     } catch (...) {
67032       {
67033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67034       };
67035     }
67036   }
67037
67038 }
67039
67040
67041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67043   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67044   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67045
67046   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67047   arg2 = (Dali::SlotObserver *)jarg2;
67048   arg3 = (Dali::CallbackBase *)jarg3;
67049   {
67050     try {
67051       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67052     } catch (std::out_of_range& e) {
67053       {
67054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67055       };
67056     } catch (std::exception& e) {
67057       {
67058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67059       };
67060     } catch (Dali::DaliException e) {
67061       {
67062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67063       };
67064     } catch (...) {
67065       {
67066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67067       };
67068     }
67069   }
67070
67071 }
67072
67073
67074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67075   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67076   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67077   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67078
67079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67080   arg2 = (Dali::SlotObserver *)jarg2;
67081   arg3 = (Dali::CallbackBase *)jarg3;
67082   {
67083     try {
67084       (arg1)->SignalDisconnected(arg2,arg3);
67085     } catch (std::out_of_range& e) {
67086       {
67087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67088       };
67089     } catch (std::exception& e) {
67090       {
67091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67092       };
67093     } catch (Dali::DaliException e) {
67094       {
67095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67096       };
67097     } catch (...) {
67098       {
67099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67100       };
67101     }
67102   }
67103
67104 }
67105
67106
67107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67109   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67110   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67111
67112   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67113   arg2 = (Dali::SlotObserver *)jarg2;
67114   arg3 = (Dali::CallbackBase *)jarg3;
67115   {
67116     try {
67117       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67118     } catch (std::out_of_range& e) {
67119       {
67120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67121       };
67122     } catch (std::exception& e) {
67123       {
67124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67125       };
67126     } catch (Dali::DaliException e) {
67127       {
67128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67129       };
67130     } catch (...) {
67131       {
67132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67133       };
67134     }
67135   }
67136
67137 }
67138
67139
67140 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) {
67141   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67142   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67143   if (director) {
67144     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);
67145   }
67146 }
67147
67148
67149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67150   void * jresult ;
67151   Dali::Toolkit::Control *arg1 = 0 ;
67152   Dali::Toolkit::Internal::Control *result = 0 ;
67153
67154   arg1 = (Dali::Toolkit::Control *)jarg1;
67155   if (!arg1) {
67156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67157     return 0;
67158   }
67159   {
67160     try {
67161       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67162     } catch (std::out_of_range& e) {
67163       {
67164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67165       };
67166     } catch (std::exception& e) {
67167       {
67168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67169       };
67170     } catch (Dali::DaliException e) {
67171       {
67172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67173       };
67174     } catch (...) {
67175       {
67176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67177       };
67178     }
67179   }
67180
67181   jresult = (void *)result;
67182   return jresult;
67183 }
67184
67185
67186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67187   int jresult ;
67188   int result;
67189
67190   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67191   jresult = (int)result;
67192   return jresult;
67193 }
67194
67195
67196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67197   int jresult ;
67198   int result;
67199
67200   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67201   jresult = (int)result;
67202   return jresult;
67203 }
67204
67205
67206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67207   int jresult ;
67208   int result;
67209
67210   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67211   jresult = (int)result;
67212   return jresult;
67213 }
67214
67215
67216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67217   int jresult ;
67218   int result;
67219
67220   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67221   jresult = (int)result;
67222   return jresult;
67223 }
67224
67225
67226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67227   int jresult ;
67228   int result;
67229
67230   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67231   jresult = (int)result;
67232   return jresult;
67233 }
67234
67235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67236   int jresult ;
67237   int result;
67238
67239   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67240   jresult = (int)result;
67241   return jresult;
67242 }
67243
67244
67245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67246   int jresult ;
67247   int result;
67248
67249   result = (int)Dali::Toolkit::Control::Property::PADDING;
67250   jresult = (int)result;
67251   return jresult;
67252 }
67253
67254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67255   void * jresult ;
67256   Dali::Toolkit::Control::Property *result = 0 ;
67257
67258   {
67259     try {
67260       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67261     } catch (std::out_of_range& e) {
67262       {
67263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67264       };
67265     } catch (std::exception& e) {
67266       {
67267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67268       };
67269     } catch (Dali::DaliException e) {
67270       {
67271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67272       };
67273     } catch (...) {
67274       {
67275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67276       };
67277     }
67278   }
67279
67280   jresult = (void *)result;
67281   return jresult;
67282 }
67283
67284
67285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67286   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67287
67288   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67289   {
67290     try {
67291       delete arg1;
67292     } catch (std::out_of_range& e) {
67293       {
67294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67295       };
67296     } catch (std::exception& e) {
67297       {
67298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67299       };
67300     } catch (Dali::DaliException e) {
67301       {
67302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67303       };
67304     } catch (...) {
67305       {
67306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67307       };
67308     }
67309   }
67310
67311 }
67312
67313
67314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67315   void * jresult ;
67316   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67317
67318   {
67319     try {
67320       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67321     } catch (std::out_of_range& e) {
67322       {
67323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67324       };
67325     } catch (std::exception& e) {
67326       {
67327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67328       };
67329     } catch (Dali::DaliException e) {
67330       {
67331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67332       };
67333     } catch (...) {
67334       {
67335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67336       };
67337     }
67338   }
67339
67340   jresult = (void *)result;
67341   return jresult;
67342 }
67343
67344
67345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67346   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67347
67348   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67349   {
67350     try {
67351       delete arg1;
67352     } catch (std::out_of_range& e) {
67353       {
67354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67355       };
67356     } catch (std::exception& e) {
67357       {
67358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67359       };
67360     } catch (Dali::DaliException e) {
67361       {
67362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67363       };
67364     } catch (...) {
67365       {
67366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67367       };
67368     }
67369   }
67370
67371 }
67372
67373
67374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67375   void * jresult ;
67376   Dali::Toolkit::Control result;
67377
67378   {
67379     try {
67380       result = Dali::Toolkit::Control::New();
67381     } catch (std::out_of_range& e) {
67382       {
67383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67384       };
67385     } catch (std::exception& e) {
67386       {
67387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67388       };
67389     } catch (Dali::DaliException e) {
67390       {
67391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67392       };
67393     } catch (...) {
67394       {
67395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67396       };
67397     }
67398   }
67399
67400   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67401   return jresult;
67402 }
67403
67404
67405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67406   void * jresult ;
67407   Dali::Toolkit::Control *result = 0 ;
67408
67409   {
67410     try {
67411       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67412     } catch (std::out_of_range& e) {
67413       {
67414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67415       };
67416     } catch (std::exception& e) {
67417       {
67418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67419       };
67420     } catch (Dali::DaliException e) {
67421       {
67422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67423       };
67424     } catch (...) {
67425       {
67426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67427       };
67428     }
67429   }
67430
67431   jresult = (void *)result;
67432   return jresult;
67433 }
67434
67435
67436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67437   void * jresult ;
67438   Dali::Toolkit::Control *arg1 = 0 ;
67439   Dali::Toolkit::Control *result = 0 ;
67440
67441   arg1 = (Dali::Toolkit::Control *)jarg1;
67442   if (!arg1) {
67443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67444     return 0;
67445   }
67446   {
67447     try {
67448       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67449     } catch (std::out_of_range& e) {
67450       {
67451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67452       };
67453     } catch (std::exception& e) {
67454       {
67455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67456       };
67457     } catch (Dali::DaliException e) {
67458       {
67459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67460       };
67461     } catch (...) {
67462       {
67463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67464       };
67465     }
67466   }
67467
67468   jresult = (void *)result;
67469   return jresult;
67470 }
67471
67472
67473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67474   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67475
67476   arg1 = (Dali::Toolkit::Control *)jarg1;
67477   {
67478     try {
67479       delete arg1;
67480     } catch (std::out_of_range& e) {
67481       {
67482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67483       };
67484     } catch (std::exception& e) {
67485       {
67486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67487       };
67488     } catch (Dali::DaliException e) {
67489       {
67490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67491       };
67492     } catch (...) {
67493       {
67494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67495       };
67496     }
67497   }
67498
67499 }
67500
67501
67502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67503   void * jresult ;
67504   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67505   Dali::Toolkit::Control *arg2 = 0 ;
67506   Dali::Toolkit::Control *result = 0 ;
67507
67508   arg1 = (Dali::Toolkit::Control *)jarg1;
67509   arg2 = (Dali::Toolkit::Control *)jarg2;
67510   if (!arg2) {
67511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67512     return 0;
67513   }
67514   {
67515     try {
67516       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67517     } catch (std::out_of_range& e) {
67518       {
67519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67520       };
67521     } catch (std::exception& e) {
67522       {
67523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67524       };
67525     } catch (Dali::DaliException e) {
67526       {
67527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67528       };
67529     } catch (...) {
67530       {
67531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67532       };
67533     }
67534   }
67535
67536   jresult = (void *)result;
67537   return jresult;
67538 }
67539
67540
67541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67542   void * jresult ;
67543   Dali::BaseHandle arg1 ;
67544   Dali::BaseHandle *argp1 ;
67545   Dali::Toolkit::Control result;
67546
67547   argp1 = (Dali::BaseHandle *)jarg1;
67548   if (!argp1) {
67549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67550     return 0;
67551   }
67552   arg1 = *argp1;
67553   {
67554     try {
67555       result = Dali::Toolkit::Control::DownCast(arg1);
67556     } catch (std::out_of_range& e) {
67557       {
67558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67559       };
67560     } catch (std::exception& e) {
67561       {
67562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67563       };
67564     } catch (Dali::DaliException e) {
67565       {
67566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67567       };
67568     } catch (...) {
67569       {
67570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67571       };
67572     }
67573   }
67574
67575   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67576   return jresult;
67577 }
67578
67579
67580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67581   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67582
67583   arg1 = (Dali::Toolkit::Control *)jarg1;
67584   {
67585     try {
67586       (arg1)->SetKeyInputFocus();
67587     } catch (std::out_of_range& e) {
67588       {
67589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67590       };
67591     } catch (std::exception& e) {
67592       {
67593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67594       };
67595     } catch (Dali::DaliException e) {
67596       {
67597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67598       };
67599     } catch (...) {
67600       {
67601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67602       };
67603     }
67604   }
67605
67606 }
67607
67608
67609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67610   unsigned int jresult ;
67611   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67612   bool result;
67613
67614   arg1 = (Dali::Toolkit::Control *)jarg1;
67615   {
67616     try {
67617       result = (bool)(arg1)->HasKeyInputFocus();
67618     } catch (std::out_of_range& e) {
67619       {
67620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67621       };
67622     } catch (std::exception& e) {
67623       {
67624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67625       };
67626     } catch (Dali::DaliException e) {
67627       {
67628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67629       };
67630     } catch (...) {
67631       {
67632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67633       };
67634     }
67635   }
67636
67637   jresult = result;
67638   return jresult;
67639 }
67640
67641
67642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67643   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67644
67645   arg1 = (Dali::Toolkit::Control *)jarg1;
67646   {
67647     try {
67648       (arg1)->ClearKeyInputFocus();
67649     } catch (std::out_of_range& e) {
67650       {
67651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67652       };
67653     } catch (std::exception& e) {
67654       {
67655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67656       };
67657     } catch (Dali::DaliException e) {
67658       {
67659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67660       };
67661     } catch (...) {
67662       {
67663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67664       };
67665     }
67666   }
67667
67668 }
67669
67670
67671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67672   void * jresult ;
67673   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67674   Dali::PinchGestureDetector result;
67675
67676   arg1 = (Dali::Toolkit::Control *)jarg1;
67677   {
67678     try {
67679       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67680     } catch (std::out_of_range& e) {
67681       {
67682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67683       };
67684     } catch (std::exception& e) {
67685       {
67686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67687       };
67688     } catch (Dali::DaliException e) {
67689       {
67690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67691       };
67692     } catch (...) {
67693       {
67694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67695       };
67696     }
67697   }
67698
67699   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67700   return jresult;
67701 }
67702
67703
67704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67705   void * jresult ;
67706   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67707   Dali::PanGestureDetector result;
67708
67709   arg1 = (Dali::Toolkit::Control *)jarg1;
67710   {
67711     try {
67712       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67713     } catch (std::out_of_range& e) {
67714       {
67715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67716       };
67717     } catch (std::exception& e) {
67718       {
67719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67720       };
67721     } catch (Dali::DaliException e) {
67722       {
67723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67724       };
67725     } catch (...) {
67726       {
67727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67728       };
67729     }
67730   }
67731
67732   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67733   return jresult;
67734 }
67735
67736
67737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67738   void * jresult ;
67739   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67740   Dali::TapGestureDetector result;
67741
67742   arg1 = (Dali::Toolkit::Control *)jarg1;
67743   {
67744     try {
67745       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67746     } catch (std::out_of_range& e) {
67747       {
67748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67749       };
67750     } catch (std::exception& e) {
67751       {
67752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67753       };
67754     } catch (Dali::DaliException e) {
67755       {
67756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67757       };
67758     } catch (...) {
67759       {
67760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67761       };
67762     }
67763   }
67764
67765   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67766   return jresult;
67767 }
67768
67769
67770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67771   void * jresult ;
67772   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67773   Dali::LongPressGestureDetector result;
67774
67775   arg1 = (Dali::Toolkit::Control *)jarg1;
67776   {
67777     try {
67778       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67779     } catch (std::out_of_range& e) {
67780       {
67781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67782       };
67783     } catch (std::exception& e) {
67784       {
67785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67786       };
67787     } catch (Dali::DaliException e) {
67788       {
67789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67790       };
67791     } catch (...) {
67792       {
67793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67794       };
67795     }
67796   }
67797
67798   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67799   return jresult;
67800 }
67801
67802
67803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67804   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67805   std::string *arg2 = 0 ;
67806
67807   arg1 = (Dali::Toolkit::Control *)jarg1;
67808   if (!jarg2) {
67809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67810     return ;
67811   }
67812   std::string arg2_str(jarg2);
67813   arg2 = &arg2_str;
67814   {
67815     try {
67816       (arg1)->SetStyleName((std::string const &)*arg2);
67817     } catch (std::out_of_range& e) {
67818       {
67819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67820       };
67821     } catch (std::exception& e) {
67822       {
67823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67824       };
67825     } catch (Dali::DaliException e) {
67826       {
67827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67828       };
67829     } catch (...) {
67830       {
67831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67832       };
67833     }
67834   }
67835
67836
67837   //argout typemap for const std::string&
67838
67839 }
67840
67841
67842 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67843   char * jresult ;
67844   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67845   std::string *result = 0 ;
67846
67847   arg1 = (Dali::Toolkit::Control *)jarg1;
67848   {
67849     try {
67850       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67851     } catch (std::out_of_range& e) {
67852       {
67853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67854       };
67855     } catch (std::exception& e) {
67856       {
67857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67858       };
67859     } catch (Dali::DaliException e) {
67860       {
67861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67862       };
67863     } catch (...) {
67864       {
67865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67866       };
67867     }
67868   }
67869
67870   jresult = SWIG_csharp_string_callback(result->c_str());
67871   return jresult;
67872 }
67873
67874
67875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67876   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67877   Dali::Vector4 *arg2 = 0 ;
67878
67879   arg1 = (Dali::Toolkit::Control *)jarg1;
67880   arg2 = (Dali::Vector4 *)jarg2;
67881   if (!arg2) {
67882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67883     return ;
67884   }
67885   {
67886     try {
67887       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67888     } catch (std::out_of_range& e) {
67889       {
67890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67891       };
67892     } catch (std::exception& e) {
67893       {
67894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67895       };
67896     } catch (Dali::DaliException e) {
67897       {
67898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67899       };
67900     } catch (...) {
67901       {
67902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67903       };
67904     }
67905   }
67906
67907 }
67908
67909
67910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67911   void * jresult ;
67912   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67913   Dali::Vector4 result;
67914
67915   arg1 = (Dali::Toolkit::Control *)jarg1;
67916   {
67917     try {
67918       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67919     } catch (std::out_of_range& e) {
67920       {
67921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67922       };
67923     } catch (std::exception& e) {
67924       {
67925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67926       };
67927     } catch (Dali::DaliException e) {
67928       {
67929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67930       };
67931     } catch (...) {
67932       {
67933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67934       };
67935     }
67936   }
67937
67938   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67939   return jresult;
67940 }
67941
67942
67943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67944   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67945   Dali::Image arg2 ;
67946   Dali::Image *argp2 ;
67947
67948   arg1 = (Dali::Toolkit::Control *)jarg1;
67949   argp2 = (Dali::Image *)jarg2;
67950   if (!argp2) {
67951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67952     return ;
67953   }
67954   arg2 = *argp2;
67955   {
67956     try {
67957       (arg1)->SetBackgroundImage(arg2);
67958     } catch (std::out_of_range& e) {
67959       {
67960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67961       };
67962     } catch (std::exception& e) {
67963       {
67964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67965       };
67966     } catch (Dali::DaliException e) {
67967       {
67968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67969       };
67970     } catch (...) {
67971       {
67972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67973       };
67974     }
67975   }
67976
67977 }
67978
67979
67980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67981   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67982
67983   arg1 = (Dali::Toolkit::Control *)jarg1;
67984   {
67985     try {
67986       (arg1)->ClearBackground();
67987     } catch (std::out_of_range& e) {
67988       {
67989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67990       };
67991     } catch (std::exception& e) {
67992       {
67993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67994       };
67995     } catch (Dali::DaliException e) {
67996       {
67997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67998       };
67999     } catch (...) {
68000       {
68001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68002       };
68003     }
68004   }
68005
68006 }
68007
68008
68009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68010   void * jresult ;
68011   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68012   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68013
68014   arg1 = (Dali::Toolkit::Control *)jarg1;
68015   {
68016     try {
68017       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68018     } catch (std::out_of_range& e) {
68019       {
68020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68021       };
68022     } catch (std::exception& e) {
68023       {
68024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68025       };
68026     } catch (Dali::DaliException e) {
68027       {
68028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68029       };
68030     } catch (...) {
68031       {
68032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68033       };
68034     }
68035   }
68036
68037   jresult = (void *)result;
68038   return jresult;
68039 }
68040
68041
68042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68043   void * jresult ;
68044   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68045   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68046
68047   arg1 = (Dali::Toolkit::Control *)jarg1;
68048   {
68049     try {
68050       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68051     } catch (std::out_of_range& e) {
68052       {
68053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68054       };
68055     } catch (std::exception& e) {
68056       {
68057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68058       };
68059     } catch (Dali::DaliException e) {
68060       {
68061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68062       };
68063     } catch (...) {
68064       {
68065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68066       };
68067     }
68068   }
68069
68070   jresult = (void *)result;
68071   return jresult;
68072 }
68073
68074
68075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68076   void * jresult ;
68077   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68078   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68079
68080   arg1 = (Dali::Toolkit::Control *)jarg1;
68081   {
68082     try {
68083       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68084     } catch (std::out_of_range& e) {
68085       {
68086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68087       };
68088     } catch (std::exception& e) {
68089       {
68090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68091       };
68092     } catch (Dali::DaliException e) {
68093       {
68094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68095       };
68096     } catch (...) {
68097       {
68098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68099       };
68100     }
68101   }
68102
68103   jresult = (void *)result;
68104   return jresult;
68105 }
68106
68107
68108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68109   void * jresult ;
68110   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68111   Dali::Toolkit::Control *result = 0 ;
68112
68113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68114   if (!arg1) {
68115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68116     return 0;
68117   }
68118   {
68119     try {
68120       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68121     } catch (std::out_of_range& e) {
68122       {
68123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68124       };
68125     } catch (std::exception& e) {
68126       {
68127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68128       };
68129     } catch (Dali::DaliException e) {
68130       {
68131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68132       };
68133     } catch (...) {
68134       {
68135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68136       };
68137     }
68138   }
68139
68140   jresult = (void *)result;
68141   return jresult;
68142 }
68143
68144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68145 {
68146   int jresult;
68147   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68148   arg1 = (Dali::Toolkit::Control *)jarg1;
68149
68150   if (!arg1) {
68151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68152     return 0;
68153   }
68154
68155   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68156
68157   Dali::Property::Index arg2 = 0 ;
68158   arg2 = (Dali::Property::Index)jarg2;
68159
68160   Toolkit::Visual::ResourceStatus result;
68161   {
68162     try {
68163       result = DevelControl::GetVisualResourceStatus(controlImpl, arg2);
68164     } catch (std::out_of_range& e) {
68165       {
68166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68167       };
68168     } catch (std::exception& e) {
68169       {
68170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68171       };
68172     } catch (...) {
68173       {
68174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68175       };
68176     }
68177   }
68178   jresult = (int)(result);
68179   return jresult;
68180 }
68181
68182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68183 {
68184   void * jresult;
68185   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68186   arg1 = (Dali::Toolkit::Control *)jarg1;
68187
68188   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68189
68190   Dali::Toolkit::TransitionData *arg2 = 0 ;
68191   Dali::Animation result;
68192
68193   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68194   if (!arg2) {
68195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68196     return 0;
68197   }
68198   {
68199     try {
68200       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68201     } catch (std::out_of_range& e) {
68202       {
68203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68204       };
68205     } catch (std::exception& e) {
68206       {
68207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68208       };
68209     } catch (Dali::DaliException e) {
68210       {
68211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68212       };
68213     } catch (...) {
68214       {
68215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68216       };
68217     }
68218   }
68219
68220   jresult = new Dali::Animation((const Dali::Animation &)result);
68221   return jresult;
68222 }
68223
68224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68225 {
68226   Dali::Toolkit::Control arg1;
68227   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68228
68229   if (!argp1) {
68230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68231   }
68232   arg1 = *argp1;
68233
68234   Dali::Property::Index arg2 = 0 ;
68235   arg2 = (Dali::Property::Index)jarg2;
68236
68237   Dali::Property::Index arg3 = 0 ;
68238   arg3 = (Dali::Property::Index)jarg3;
68239
68240   Dali::Property::Value arg4;
68241   arg4 = (Dali::Property::Value *)jarg4;
68242
68243   {
68244     try {
68245       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68246     } catch (std::out_of_range& e) {
68247       {
68248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68249       };
68250     } catch (std::exception& e) {
68251       {
68252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68253       };
68254     } catch (...) {
68255       {
68256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68257       };
68258     }
68259   }
68260
68261
68262 }
68263
68264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68265   void * jresult ;
68266   Dali::Toolkit::Control *arg1 = 0 ;
68267   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68268
68269   arg1 = (Dali::Toolkit::Control *)jarg1;
68270   if (!arg1) {
68271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68272     return 0;
68273   }
68274   {
68275     try {
68276       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68277     } catch (std::out_of_range& e) {
68278       {
68279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68280       };
68281     } catch (std::exception& e) {
68282       {
68283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68284       };
68285     } catch (Dali::DaliException e) {
68286       {
68287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68288       };
68289     } catch (...) {
68290       {
68291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68292       };
68293     }
68294   }
68295
68296   jresult = (void *)result;
68297   return jresult;
68298 }
68299
68300
68301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68302   unsigned int jresult ;
68303   Dali::Toolkit::Control *arg1 = 0 ;
68304   bool result;
68305
68306   arg1 = (Dali::Toolkit::Control *)jarg1;
68307   if (!arg1) {
68308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68309     return 0;
68310   }
68311   {
68312     try {
68313       result = (bool)arg1->IsResourceReady();
68314     } catch (std::out_of_range& e) {
68315       {
68316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68317       };
68318     } catch (std::exception& e) {
68319       {
68320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68321       };
68322     } catch (Dali::DaliException e) {
68323       {
68324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68325       };
68326     } catch (...) {
68327       {
68328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68329       };
68330     }
68331   }
68332
68333   jresult = result;
68334   return jresult;
68335 }
68336
68337
68338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68339   void * jresult ;
68340   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68341
68342   {
68343     try {
68344       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68345     } catch (std::out_of_range& e) {
68346       {
68347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68348       };
68349     } catch (std::exception& e) {
68350       {
68351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68352       };
68353     } catch (Dali::DaliException e) {
68354       {
68355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68356       };
68357     } catch (...) {
68358       {
68359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68360       };
68361     }
68362   }
68363
68364   jresult = (void *)result;
68365   return jresult;
68366 }
68367
68368
68369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68370   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68371
68372   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68373   {
68374     try {
68375       delete arg1;
68376     } catch (std::out_of_range& e) {
68377       {
68378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68379       };
68380     } catch (std::exception& e) {
68381       {
68382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68383       };
68384     } catch (Dali::DaliException e) {
68385       {
68386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68387       };
68388     } catch (...) {
68389       {
68390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68391       };
68392     }
68393   }
68394
68395 }
68396
68397
68398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68399   void * jresult ;
68400   Dali::Toolkit::KeyInputFocusManager result;
68401
68402   {
68403     try {
68404       result = Dali::Toolkit::KeyInputFocusManager::Get();
68405     } catch (std::out_of_range& e) {
68406       {
68407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68408       };
68409     } catch (std::exception& e) {
68410       {
68411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68412       };
68413     } catch (Dali::DaliException e) {
68414       {
68415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68416       };
68417     } catch (...) {
68418       {
68419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68420       };
68421     }
68422   }
68423
68424   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68425   return jresult;
68426 }
68427
68428
68429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68430   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68431   Dali::Toolkit::Control arg2 ;
68432   Dali::Toolkit::Control *argp2 ;
68433
68434   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68435   argp2 = (Dali::Toolkit::Control *)jarg2;
68436   if (!argp2) {
68437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68438     return ;
68439   }
68440   arg2 = *argp2;
68441   {
68442     try {
68443       (arg1)->SetFocus(arg2);
68444     } catch (std::out_of_range& e) {
68445       {
68446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68447       };
68448     } catch (std::exception& e) {
68449       {
68450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68451       };
68452     } catch (Dali::DaliException e) {
68453       {
68454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68455       };
68456     } catch (...) {
68457       {
68458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68459       };
68460     }
68461   }
68462
68463 }
68464
68465
68466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68467   void * jresult ;
68468   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68469   Dali::Toolkit::Control result;
68470
68471   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68472   {
68473     try {
68474       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68475     } catch (std::out_of_range& e) {
68476       {
68477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68478       };
68479     } catch (std::exception& e) {
68480       {
68481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68482       };
68483     } catch (Dali::DaliException e) {
68484       {
68485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68486       };
68487     } catch (...) {
68488       {
68489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68490       };
68491     }
68492   }
68493
68494   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68495   return jresult;
68496 }
68497
68498
68499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68500   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68501   Dali::Toolkit::Control arg2 ;
68502   Dali::Toolkit::Control *argp2 ;
68503
68504   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68505   argp2 = (Dali::Toolkit::Control *)jarg2;
68506   if (!argp2) {
68507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68508     return ;
68509   }
68510   arg2 = *argp2;
68511   {
68512     try {
68513       (arg1)->RemoveFocus(arg2);
68514     } catch (std::out_of_range& e) {
68515       {
68516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68517       };
68518     } catch (std::exception& e) {
68519       {
68520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68521       };
68522     } catch (Dali::DaliException e) {
68523       {
68524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68525       };
68526     } catch (...) {
68527       {
68528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68529       };
68530     }
68531   }
68532
68533 }
68534
68535
68536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68537   void * jresult ;
68538   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68539   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68540
68541   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68542   {
68543     try {
68544       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68545     } catch (std::out_of_range& e) {
68546       {
68547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68548       };
68549     } catch (std::exception& e) {
68550       {
68551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68552       };
68553     } catch (Dali::DaliException e) {
68554       {
68555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68556       };
68557     } catch (...) {
68558       {
68559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68560       };
68561     }
68562   }
68563
68564   jresult = (void *)result;
68565   return jresult;
68566 }
68567
68568
68569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68570   void * jresult ;
68571   Dali::Toolkit::Alignment::Padding *result = 0 ;
68572
68573   {
68574     try {
68575       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68576     } catch (std::out_of_range& e) {
68577       {
68578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68579       };
68580     } catch (std::exception& e) {
68581       {
68582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68583       };
68584     } catch (Dali::DaliException e) {
68585       {
68586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68587       };
68588     } catch (...) {
68589       {
68590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68591       };
68592     }
68593   }
68594
68595   jresult = (void *)result;
68596   return jresult;
68597 }
68598
68599
68600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68601   void * jresult ;
68602   float arg1 ;
68603   float arg2 ;
68604   float arg3 ;
68605   float arg4 ;
68606   Dali::Toolkit::Alignment::Padding *result = 0 ;
68607
68608   arg1 = (float)jarg1;
68609   arg2 = (float)jarg2;
68610   arg3 = (float)jarg3;
68611   arg4 = (float)jarg4;
68612   {
68613     try {
68614       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68615     } catch (std::out_of_range& e) {
68616       {
68617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68618       };
68619     } catch (std::exception& e) {
68620       {
68621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68622       };
68623     } catch (Dali::DaliException e) {
68624       {
68625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68626       };
68627     } catch (...) {
68628       {
68629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68630       };
68631     }
68632   }
68633
68634   jresult = (void *)result;
68635   return jresult;
68636 }
68637
68638
68639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68640   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68641   float arg2 ;
68642
68643   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68644   arg2 = (float)jarg2;
68645   if (arg1) (arg1)->left = arg2;
68646 }
68647
68648
68649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68650   float jresult ;
68651   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68652   float result;
68653
68654   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68655   result = (float) ((arg1)->left);
68656   jresult = result;
68657   return jresult;
68658 }
68659
68660
68661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68662   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68663   float arg2 ;
68664
68665   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68666   arg2 = (float)jarg2;
68667   if (arg1) (arg1)->right = arg2;
68668 }
68669
68670
68671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68672   float jresult ;
68673   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68674   float result;
68675
68676   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68677   result = (float) ((arg1)->right);
68678   jresult = result;
68679   return jresult;
68680 }
68681
68682
68683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68684   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68685   float arg2 ;
68686
68687   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68688   arg2 = (float)jarg2;
68689   if (arg1) (arg1)->top = arg2;
68690 }
68691
68692
68693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68694   float jresult ;
68695   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68696   float result;
68697
68698   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68699   result = (float) ((arg1)->top);
68700   jresult = result;
68701   return jresult;
68702 }
68703
68704
68705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68706   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68707   float arg2 ;
68708
68709   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68710   arg2 = (float)jarg2;
68711   if (arg1) (arg1)->bottom = arg2;
68712 }
68713
68714
68715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68716   float jresult ;
68717   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68718   float result;
68719
68720   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68721   result = (float) ((arg1)->bottom);
68722   jresult = result;
68723   return jresult;
68724 }
68725
68726
68727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68728   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68729
68730   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68731   {
68732     try {
68733       delete arg1;
68734     } catch (std::out_of_range& e) {
68735       {
68736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68737       };
68738     } catch (std::exception& e) {
68739       {
68740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68741       };
68742     } catch (Dali::DaliException e) {
68743       {
68744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68745       };
68746     } catch (...) {
68747       {
68748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68749       };
68750     }
68751   }
68752
68753 }
68754
68755
68756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68757   void * jresult ;
68758   Dali::Toolkit::Alignment *result = 0 ;
68759
68760   {
68761     try {
68762       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68763     } catch (std::out_of_range& e) {
68764       {
68765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68766       };
68767     } catch (std::exception& e) {
68768       {
68769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68770       };
68771     } catch (Dali::DaliException e) {
68772       {
68773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68774       };
68775     } catch (...) {
68776       {
68777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68778       };
68779     }
68780   }
68781
68782   jresult = (void *)result;
68783   return jresult;
68784 }
68785
68786
68787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68788   void * jresult ;
68789   Dali::Toolkit::Alignment::Type arg1 ;
68790   Dali::Toolkit::Alignment::Type arg2 ;
68791   Dali::Toolkit::Alignment result;
68792
68793   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68794   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68795   {
68796     try {
68797       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68798     } catch (std::out_of_range& e) {
68799       {
68800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68801       };
68802     } catch (std::exception& e) {
68803       {
68804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68805       };
68806     } catch (Dali::DaliException e) {
68807       {
68808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68809       };
68810     } catch (...) {
68811       {
68812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68813       };
68814     }
68815   }
68816
68817   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68818   return jresult;
68819 }
68820
68821
68822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68823   void * jresult ;
68824   Dali::Toolkit::Alignment::Type arg1 ;
68825   Dali::Toolkit::Alignment result;
68826
68827   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68828   {
68829     try {
68830       result = Dali::Toolkit::Alignment::New(arg1);
68831     } catch (std::out_of_range& e) {
68832       {
68833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68834       };
68835     } catch (std::exception& e) {
68836       {
68837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68838       };
68839     } catch (Dali::DaliException e) {
68840       {
68841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68842       };
68843     } catch (...) {
68844       {
68845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68846       };
68847     }
68848   }
68849
68850   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68851   return jresult;
68852 }
68853
68854
68855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68856   void * jresult ;
68857   Dali::Toolkit::Alignment result;
68858
68859   {
68860     try {
68861       result = Dali::Toolkit::Alignment::New();
68862     } catch (std::out_of_range& e) {
68863       {
68864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68865       };
68866     } catch (std::exception& e) {
68867       {
68868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68869       };
68870     } catch (Dali::DaliException e) {
68871       {
68872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68873       };
68874     } catch (...) {
68875       {
68876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68877       };
68878     }
68879   }
68880
68881   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68882   return jresult;
68883 }
68884
68885
68886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68887   void * jresult ;
68888   Dali::Toolkit::Alignment *arg1 = 0 ;
68889   Dali::Toolkit::Alignment *result = 0 ;
68890
68891   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68892   if (!arg1) {
68893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68894     return 0;
68895   }
68896   {
68897     try {
68898       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68899     } catch (std::out_of_range& e) {
68900       {
68901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68902       };
68903     } catch (std::exception& e) {
68904       {
68905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68906       };
68907     } catch (Dali::DaliException e) {
68908       {
68909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68910       };
68911     } catch (...) {
68912       {
68913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68914       };
68915     }
68916   }
68917
68918   jresult = (void *)result;
68919   return jresult;
68920 }
68921
68922
68923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68924   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68925
68926   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68927   {
68928     try {
68929       delete arg1;
68930     } catch (std::out_of_range& e) {
68931       {
68932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68933       };
68934     } catch (std::exception& e) {
68935       {
68936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68937       };
68938     } catch (Dali::DaliException e) {
68939       {
68940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68941       };
68942     } catch (...) {
68943       {
68944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68945       };
68946     }
68947   }
68948
68949 }
68950
68951
68952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68953   void * jresult ;
68954   Dali::BaseHandle arg1 ;
68955   Dali::BaseHandle *argp1 ;
68956   Dali::Toolkit::Alignment result;
68957
68958   argp1 = (Dali::BaseHandle *)jarg1;
68959   if (!argp1) {
68960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68961     return 0;
68962   }
68963   arg1 = *argp1;
68964   {
68965     try {
68966       result = Dali::Toolkit::Alignment::DownCast(arg1);
68967     } catch (std::out_of_range& e) {
68968       {
68969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68970       };
68971     } catch (std::exception& e) {
68972       {
68973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68974       };
68975     } catch (Dali::DaliException e) {
68976       {
68977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68978       };
68979     } catch (...) {
68980       {
68981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68982       };
68983     }
68984   }
68985
68986   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68987   return jresult;
68988 }
68989
68990
68991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68992   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68993   Dali::Toolkit::Alignment::Type arg2 ;
68994
68995   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68996   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68997   {
68998     try {
68999       (arg1)->SetAlignmentType(arg2);
69000     } catch (std::out_of_range& e) {
69001       {
69002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69003       };
69004     } catch (std::exception& e) {
69005       {
69006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69007       };
69008     } catch (Dali::DaliException e) {
69009       {
69010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69011       };
69012     } catch (...) {
69013       {
69014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69015       };
69016     }
69017   }
69018
69019 }
69020
69021
69022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69023   int jresult ;
69024   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69025   Dali::Toolkit::Alignment::Type result;
69026
69027   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69028   {
69029     try {
69030       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69031     } catch (std::out_of_range& e) {
69032       {
69033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69034       };
69035     } catch (std::exception& e) {
69036       {
69037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69038       };
69039     } catch (Dali::DaliException e) {
69040       {
69041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69042       };
69043     } catch (...) {
69044       {
69045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69046       };
69047     }
69048   }
69049
69050   jresult = (int)result;
69051   return jresult;
69052 }
69053
69054
69055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69056   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69057   Dali::Toolkit::Alignment::Scaling arg2 ;
69058
69059   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69060   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69061   {
69062     try {
69063       (arg1)->SetScaling(arg2);
69064     } catch (std::out_of_range& e) {
69065       {
69066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69067       };
69068     } catch (std::exception& e) {
69069       {
69070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69071       };
69072     } catch (Dali::DaliException e) {
69073       {
69074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69075       };
69076     } catch (...) {
69077       {
69078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69079       };
69080     }
69081   }
69082
69083 }
69084
69085
69086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69087   int jresult ;
69088   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69089   Dali::Toolkit::Alignment::Scaling result;
69090
69091   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69092   {
69093     try {
69094       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69095     } catch (std::out_of_range& e) {
69096       {
69097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69098       };
69099     } catch (std::exception& e) {
69100       {
69101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69102       };
69103     } catch (Dali::DaliException e) {
69104       {
69105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69106       };
69107     } catch (...) {
69108       {
69109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69110       };
69111     }
69112   }
69113
69114   jresult = (int)result;
69115   return jresult;
69116 }
69117
69118
69119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69120   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69121   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69122
69123   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69124   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69125   if (!arg2) {
69126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69127     return ;
69128   }
69129   {
69130     try {
69131       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69132     } catch (std::out_of_range& e) {
69133       {
69134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69135       };
69136     } catch (std::exception& e) {
69137       {
69138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69139       };
69140     } catch (Dali::DaliException e) {
69141       {
69142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69143       };
69144     } catch (...) {
69145       {
69146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69147       };
69148     }
69149   }
69150
69151 }
69152
69153
69154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69155   void * jresult ;
69156   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69157   Dali::Toolkit::Alignment::Padding *result = 0 ;
69158
69159   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69160   {
69161     try {
69162       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69163     } catch (std::out_of_range& e) {
69164       {
69165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69166       };
69167     } catch (std::exception& e) {
69168       {
69169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69170       };
69171     } catch (Dali::DaliException e) {
69172       {
69173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69174       };
69175     } catch (...) {
69176       {
69177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69178       };
69179     }
69180   }
69181
69182   jresult = (void *)result;
69183   return jresult;
69184 }
69185
69186
69187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69188   void * jresult ;
69189   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69190   Dali::Toolkit::Alignment *arg2 = 0 ;
69191   Dali::Toolkit::Alignment *result = 0 ;
69192
69193   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69194   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69195   if (!arg2) {
69196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69197     return 0;
69198   }
69199   {
69200     try {
69201       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69202     } catch (std::out_of_range& e) {
69203       {
69204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69205       };
69206     } catch (std::exception& e) {
69207       {
69208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69209       };
69210     } catch (Dali::DaliException e) {
69211       {
69212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69213       };
69214     } catch (...) {
69215       {
69216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69217       };
69218     }
69219   }
69220
69221   jresult = (void *)result;
69222   return jresult;
69223 }
69224
69225
69226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69227   int jresult ;
69228   int result;
69229
69230   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69231   jresult = (int)result;
69232   return jresult;
69233 }
69234
69235
69236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69237   int jresult ;
69238   int result;
69239
69240   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69241   jresult = (int)result;
69242   return jresult;
69243 }
69244
69245
69246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69247   int jresult ;
69248   int result;
69249
69250   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69251   jresult = (int)result;
69252   return jresult;
69253 }
69254
69255
69256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69257   int jresult ;
69258   int result;
69259
69260   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69261   jresult = (int)result;
69262   return jresult;
69263 }
69264
69265
69266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69267   int jresult ;
69268   int result;
69269
69270   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69271   jresult = (int)result;
69272   return jresult;
69273 }
69274
69275
69276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69277   int jresult ;
69278   int result;
69279
69280   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69281   jresult = (int)result;
69282   return jresult;
69283 }
69284
69285
69286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69287   int jresult ;
69288   int result;
69289
69290   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69291   jresult = (int)result;
69292   return jresult;
69293 }
69294
69295
69296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69297   int jresult ;
69298   int result;
69299
69300   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69301   jresult = (int)result;
69302   return jresult;
69303 }
69304
69305
69306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69307   int jresult ;
69308   int result;
69309
69310   result = (int)Dali::Toolkit::Button::Property::LABEL;
69311   jresult = (int)result;
69312   return jresult;
69313 }
69314
69315
69316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69317   int jresult ;
69318   int result;
69319
69320   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69321   jresult = (int)result;
69322   return jresult;
69323 }
69324
69325
69326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69327   void * jresult ;
69328   Dali::Toolkit::Button::Property *result = 0 ;
69329
69330   {
69331     try {
69332       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69333     } catch (std::out_of_range& e) {
69334       {
69335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69336       };
69337     } catch (std::exception& e) {
69338       {
69339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69340       };
69341     } catch (Dali::DaliException e) {
69342       {
69343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69344       };
69345     } catch (...) {
69346       {
69347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69348       };
69349     }
69350   }
69351
69352   jresult = (void *)result;
69353   return jresult;
69354 }
69355
69356
69357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69358   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69359
69360   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69361   {
69362     try {
69363       delete arg1;
69364     } catch (std::out_of_range& e) {
69365       {
69366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69367       };
69368     } catch (std::exception& e) {
69369       {
69370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69371       };
69372     } catch (Dali::DaliException e) {
69373       {
69374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69375       };
69376     } catch (...) {
69377       {
69378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69379       };
69380     }
69381   }
69382
69383 }
69384
69385
69386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69387   void * jresult ;
69388   Dali::Toolkit::Button *result = 0 ;
69389
69390   {
69391     try {
69392       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69393     } catch (std::out_of_range& e) {
69394       {
69395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69396       };
69397     } catch (std::exception& e) {
69398       {
69399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69400       };
69401     } catch (Dali::DaliException e) {
69402       {
69403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69404       };
69405     } catch (...) {
69406       {
69407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69408       };
69409     }
69410   }
69411
69412   jresult = (void *)result;
69413   return jresult;
69414 }
69415
69416
69417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69418   void * jresult ;
69419   Dali::Toolkit::Button *arg1 = 0 ;
69420   Dali::Toolkit::Button *result = 0 ;
69421
69422   arg1 = (Dali::Toolkit::Button *)jarg1;
69423   if (!arg1) {
69424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69425     return 0;
69426   }
69427   {
69428     try {
69429       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69430     } catch (std::out_of_range& e) {
69431       {
69432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69433       };
69434     } catch (std::exception& e) {
69435       {
69436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69437       };
69438     } catch (Dali::DaliException e) {
69439       {
69440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69441       };
69442     } catch (...) {
69443       {
69444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69445       };
69446     }
69447   }
69448
69449   jresult = (void *)result;
69450   return jresult;
69451 }
69452
69453
69454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69455   void * jresult ;
69456   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69457   Dali::Toolkit::Button *arg2 = 0 ;
69458   Dali::Toolkit::Button *result = 0 ;
69459
69460   arg1 = (Dali::Toolkit::Button *)jarg1;
69461   arg2 = (Dali::Toolkit::Button *)jarg2;
69462   if (!arg2) {
69463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69464     return 0;
69465   }
69466   {
69467     try {
69468       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69469     } catch (std::out_of_range& e) {
69470       {
69471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69472       };
69473     } catch (std::exception& e) {
69474       {
69475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69476       };
69477     } catch (Dali::DaliException e) {
69478       {
69479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69480       };
69481     } catch (...) {
69482       {
69483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69484       };
69485     }
69486   }
69487
69488   jresult = (void *)result;
69489   return jresult;
69490 }
69491
69492
69493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69494   void * jresult ;
69495   Dali::BaseHandle arg1 ;
69496   Dali::BaseHandle *argp1 ;
69497   Dali::Toolkit::Button result;
69498
69499   argp1 = (Dali::BaseHandle *)jarg1;
69500   if (!argp1) {
69501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69502     return 0;
69503   }
69504   arg1 = *argp1;
69505   {
69506     try {
69507       result = Dali::Toolkit::Button::DownCast(arg1);
69508     } catch (std::out_of_range& e) {
69509       {
69510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69511       };
69512     } catch (std::exception& e) {
69513       {
69514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69515       };
69516     } catch (Dali::DaliException e) {
69517       {
69518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69519       };
69520     } catch (...) {
69521       {
69522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69523       };
69524     }
69525   }
69526
69527   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69528   return jresult;
69529 }
69530
69531
69532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69533   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69534
69535   arg1 = (Dali::Toolkit::Button *)jarg1;
69536   {
69537     try {
69538       delete arg1;
69539     } catch (std::out_of_range& e) {
69540       {
69541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69542       };
69543     } catch (std::exception& e) {
69544       {
69545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69546       };
69547     } catch (Dali::DaliException e) {
69548       {
69549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69550       };
69551     } catch (...) {
69552       {
69553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69554       };
69555     }
69556   }
69557
69558 }
69559
69560
69561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69562   unsigned int jresult ;
69563   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69564   bool result;
69565
69566   arg1 = (Dali::Toolkit::Button *)jarg1;
69567   {
69568     try {
69569       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69570     } catch (std::out_of_range& e) {
69571       {
69572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69573       };
69574     } catch (std::exception& e) {
69575       {
69576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69577       };
69578     } catch (Dali::DaliException e) {
69579       {
69580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69581       };
69582     } catch (...) {
69583       {
69584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69585       };
69586     }
69587   }
69588
69589   jresult = result;
69590   return jresult;
69591 }
69592
69593
69594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69595   unsigned int jresult ;
69596   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69597   bool result;
69598
69599   arg1 = (Dali::Toolkit::Button *)jarg1;
69600   {
69601     try {
69602       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69603     } catch (std::out_of_range& e) {
69604       {
69605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69606       };
69607     } catch (std::exception& e) {
69608       {
69609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69610       };
69611     } catch (Dali::DaliException e) {
69612       {
69613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69614       };
69615     } catch (...) {
69616       {
69617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69618       };
69619     }
69620   }
69621
69622   jresult = result;
69623   return jresult;
69624 }
69625
69626
69627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69628   float jresult ;
69629   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69630   float result;
69631
69632   arg1 = (Dali::Toolkit::Button *)jarg1;
69633   {
69634     try {
69635       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69636     } catch (std::out_of_range& e) {
69637       {
69638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69639       };
69640     } catch (std::exception& e) {
69641       {
69642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69643       };
69644     } catch (Dali::DaliException e) {
69645       {
69646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69647       };
69648     } catch (...) {
69649       {
69650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69651       };
69652     }
69653   }
69654
69655   jresult = result;
69656   return jresult;
69657 }
69658
69659
69660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69661   float jresult ;
69662   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69663   float result;
69664
69665   arg1 = (Dali::Toolkit::Button *)jarg1;
69666   {
69667     try {
69668       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69669     } catch (std::out_of_range& e) {
69670       {
69671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69672       };
69673     } catch (std::exception& e) {
69674       {
69675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69676       };
69677     } catch (Dali::DaliException e) {
69678       {
69679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69680       };
69681     } catch (...) {
69682       {
69683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69684       };
69685     }
69686   }
69687
69688   jresult = result;
69689   return jresult;
69690 }
69691
69692
69693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69694   unsigned int jresult ;
69695   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69696   bool result;
69697
69698   arg1 = (Dali::Toolkit::Button *)jarg1;
69699   {
69700     try {
69701       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69702     } catch (std::out_of_range& e) {
69703       {
69704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69705       };
69706     } catch (std::exception& e) {
69707       {
69708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69709       };
69710     } catch (Dali::DaliException e) {
69711       {
69712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69713       };
69714     } catch (...) {
69715       {
69716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69717       };
69718     }
69719   }
69720
69721   jresult = result;
69722   return jresult;
69723 }
69724
69725
69726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69727   unsigned int jresult ;
69728   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69729   bool result;
69730
69731   arg1 = (Dali::Toolkit::Button *)jarg1;
69732   {
69733     try {
69734       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69735     } catch (std::out_of_range& e) {
69736       {
69737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69738       };
69739     } catch (std::exception& e) {
69740       {
69741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69742       };
69743     } catch (Dali::DaliException e) {
69744       {
69745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69746       };
69747     } catch (...) {
69748       {
69749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69750       };
69751     }
69752   }
69753
69754   jresult = result;
69755   return jresult;
69756 }
69757
69758
69759 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69760   float jresult ;
69761   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69762   float result;
69763
69764   arg1 = (Dali::Toolkit::Button *)jarg1;
69765   {
69766     try {
69767       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69768     } catch (std::out_of_range& e) {
69769       {
69770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69771       };
69772     } catch (std::exception& e) {
69773       {
69774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69775       };
69776     } catch (Dali::DaliException e) {
69777       {
69778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69779       };
69780     } catch (...) {
69781       {
69782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69783       };
69784     }
69785   }
69786
69787   jresult = result;
69788   return jresult;
69789 }
69790
69791
69792 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69793   char * jresult ;
69794   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69795   std::string result;
69796
69797   arg1 = (Dali::Toolkit::Button *)jarg1;
69798   {
69799     try {
69800       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69801     } catch (std::out_of_range& e) {
69802       {
69803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69804       };
69805     } catch (std::exception& e) {
69806       {
69807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69808       };
69809     } catch (Dali::DaliException e) {
69810       {
69811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69812       };
69813     } catch (...) {
69814       {
69815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69816       };
69817     }
69818   }
69819
69820   jresult = SWIG_csharp_string_callback((&result)->c_str());
69821   return jresult;
69822 }
69823
69824
69825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69826   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69827   Dali::Actor arg2 ;
69828   Dali::Actor *argp2 ;
69829
69830   arg1 = (Dali::Toolkit::Button *)jarg1;
69831   argp2 = (Dali::Actor *)jarg2;
69832   if (!argp2) {
69833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69834     return ;
69835   }
69836   arg2 = *argp2;
69837   {
69838     try {
69839       (arg1)->SetLabel(arg2);
69840     } catch (std::out_of_range& e) {
69841       {
69842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69843       };
69844     } catch (std::exception& e) {
69845       {
69846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69847       };
69848     } catch (Dali::DaliException e) {
69849       {
69850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69851       };
69852     } catch (...) {
69853       {
69854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69855       };
69856     }
69857   }
69858
69859 }
69860
69861
69862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69863   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69864   Dali::Image arg2 ;
69865   Dali::Image *argp2 ;
69866
69867   arg1 = (Dali::Toolkit::Button *)jarg1;
69868   argp2 = (Dali::Image *)jarg2;
69869   if (!argp2) {
69870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69871     return ;
69872   }
69873   arg2 = *argp2;
69874   {
69875     try {
69876       (arg1)->SetButtonImage(arg2);
69877     } catch (std::out_of_range& e) {
69878       {
69879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69880       };
69881     } catch (std::exception& e) {
69882       {
69883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69884       };
69885     } catch (Dali::DaliException e) {
69886       {
69887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69888       };
69889     } catch (...) {
69890       {
69891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69892       };
69893     }
69894   }
69895
69896 }
69897
69898
69899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69900   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69901   Dali::Image arg2 ;
69902   Dali::Image *argp2 ;
69903
69904   arg1 = (Dali::Toolkit::Button *)jarg1;
69905   argp2 = (Dali::Image *)jarg2;
69906   if (!argp2) {
69907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69908     return ;
69909   }
69910   arg2 = *argp2;
69911   {
69912     try {
69913       (arg1)->SetSelectedImage(arg2);
69914     } catch (std::out_of_range& e) {
69915       {
69916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69917       };
69918     } catch (std::exception& e) {
69919       {
69920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69921       };
69922     } catch (Dali::DaliException e) {
69923       {
69924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69925       };
69926     } catch (...) {
69927       {
69928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69929       };
69930     }
69931   }
69932
69933 }
69934
69935
69936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69937   void * jresult ;
69938   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69939   Dali::Actor result;
69940
69941   arg1 = (Dali::Toolkit::Button *)jarg1;
69942   {
69943     try {
69944       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69945     } catch (std::out_of_range& e) {
69946       {
69947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69948       };
69949     } catch (std::exception& e) {
69950       {
69951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69952       };
69953     } catch (Dali::DaliException e) {
69954       {
69955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69956       };
69957     } catch (...) {
69958       {
69959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69960       };
69961     }
69962   }
69963
69964   jresult = new Dali::Actor((const Dali::Actor &)result);
69965   return jresult;
69966 }
69967
69968
69969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69970   void * jresult ;
69971   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69972   Dali::Actor result;
69973
69974   arg1 = (Dali::Toolkit::Button *)jarg1;
69975   {
69976     try {
69977       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69978     } catch (std::out_of_range& e) {
69979       {
69980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69981       };
69982     } catch (std::exception& e) {
69983       {
69984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69985       };
69986     } catch (Dali::DaliException e) {
69987       {
69988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69989       };
69990     } catch (...) {
69991       {
69992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69993       };
69994     }
69995   }
69996
69997   jresult = new Dali::Actor((const Dali::Actor &)result);
69998   return jresult;
69999 }
70000
70001
70002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70003   void * jresult ;
70004   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70005   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70006
70007   arg1 = (Dali::Toolkit::Button *)jarg1;
70008   {
70009     try {
70010       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70011     } catch (std::out_of_range& e) {
70012       {
70013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70014       };
70015     } catch (std::exception& e) {
70016       {
70017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70018       };
70019     } catch (Dali::DaliException e) {
70020       {
70021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70022       };
70023     } catch (...) {
70024       {
70025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70026       };
70027     }
70028   }
70029
70030   jresult = (void *)result;
70031   return jresult;
70032 }
70033
70034
70035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70036   void * jresult ;
70037   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70038   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70039
70040   arg1 = (Dali::Toolkit::Button *)jarg1;
70041   {
70042     try {
70043       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70044     } catch (std::out_of_range& e) {
70045       {
70046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70047       };
70048     } catch (std::exception& e) {
70049       {
70050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70051       };
70052     } catch (Dali::DaliException e) {
70053       {
70054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70055       };
70056     } catch (...) {
70057       {
70058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70059       };
70060     }
70061   }
70062
70063   jresult = (void *)result;
70064   return jresult;
70065 }
70066
70067
70068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70069   void * jresult ;
70070   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70071   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70072
70073   arg1 = (Dali::Toolkit::Button *)jarg1;
70074   {
70075     try {
70076       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70077     } catch (std::out_of_range& e) {
70078       {
70079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70080       };
70081     } catch (std::exception& e) {
70082       {
70083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70084       };
70085     } catch (Dali::DaliException e) {
70086       {
70087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70088       };
70089     } catch (...) {
70090       {
70091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70092       };
70093     }
70094   }
70095
70096   jresult = (void *)result;
70097   return jresult;
70098 }
70099
70100
70101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70102   void * jresult ;
70103   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70104   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70105
70106   arg1 = (Dali::Toolkit::Button *)jarg1;
70107   {
70108     try {
70109       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70110     } catch (std::out_of_range& e) {
70111       {
70112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70113       };
70114     } catch (std::exception& e) {
70115       {
70116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70117       };
70118     } catch (Dali::DaliException e) {
70119       {
70120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70121       };
70122     } catch (...) {
70123       {
70124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70125       };
70126     }
70127   }
70128
70129   jresult = (void *)result;
70130   return jresult;
70131 }
70132
70133
70134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70135   void * jresult ;
70136   Dali::Toolkit::CheckBoxButton *result = 0 ;
70137
70138   {
70139     try {
70140       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70141     } catch (std::out_of_range& e) {
70142       {
70143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70144       };
70145     } catch (std::exception& e) {
70146       {
70147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70148       };
70149     } catch (Dali::DaliException e) {
70150       {
70151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70152       };
70153     } catch (...) {
70154       {
70155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70156       };
70157     }
70158   }
70159
70160   jresult = (void *)result;
70161   return jresult;
70162 }
70163
70164
70165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70166   void * jresult ;
70167   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70168   Dali::Toolkit::CheckBoxButton *result = 0 ;
70169
70170   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70171   if (!arg1) {
70172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70173     return 0;
70174   }
70175   {
70176     try {
70177       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70178     } catch (std::out_of_range& e) {
70179       {
70180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70181       };
70182     } catch (std::exception& e) {
70183       {
70184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70185       };
70186     } catch (Dali::DaliException e) {
70187       {
70188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70189       };
70190     } catch (...) {
70191       {
70192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70193       };
70194     }
70195   }
70196
70197   jresult = (void *)result;
70198   return jresult;
70199 }
70200
70201
70202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70203   void * jresult ;
70204   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70205   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70206   Dali::Toolkit::CheckBoxButton *result = 0 ;
70207
70208   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70209   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70210   if (!arg2) {
70211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70212     return 0;
70213   }
70214   {
70215     try {
70216       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70217     } catch (std::out_of_range& e) {
70218       {
70219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70220       };
70221     } catch (std::exception& e) {
70222       {
70223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70224       };
70225     } catch (Dali::DaliException e) {
70226       {
70227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70228       };
70229     } catch (...) {
70230       {
70231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70232       };
70233     }
70234   }
70235
70236   jresult = (void *)result;
70237   return jresult;
70238 }
70239
70240
70241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70242   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70243
70244   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70245   {
70246     try {
70247       delete arg1;
70248     } catch (std::out_of_range& e) {
70249       {
70250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70251       };
70252     } catch (std::exception& e) {
70253       {
70254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70255       };
70256     } catch (Dali::DaliException e) {
70257       {
70258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70259       };
70260     } catch (...) {
70261       {
70262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70263       };
70264     }
70265   }
70266
70267 }
70268
70269
70270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70271   void * jresult ;
70272   Dali::Toolkit::CheckBoxButton result;
70273
70274   {
70275     try {
70276       result = Dali::Toolkit::CheckBoxButton::New();
70277     } catch (std::out_of_range& e) {
70278       {
70279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70280       };
70281     } catch (std::exception& e) {
70282       {
70283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70284       };
70285     } catch (Dali::DaliException e) {
70286       {
70287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70288       };
70289     } catch (...) {
70290       {
70291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70292       };
70293     }
70294   }
70295
70296   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70297   return jresult;
70298 }
70299
70300
70301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70302   void * jresult ;
70303   Dali::BaseHandle arg1 ;
70304   Dali::BaseHandle *argp1 ;
70305   Dali::Toolkit::CheckBoxButton result;
70306
70307   argp1 = (Dali::BaseHandle *)jarg1;
70308   if (!argp1) {
70309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70310     return 0;
70311   }
70312   arg1 = *argp1;
70313   {
70314     try {
70315       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70316     } catch (std::out_of_range& e) {
70317       {
70318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70319       };
70320     } catch (std::exception& e) {
70321       {
70322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70323       };
70324     } catch (Dali::DaliException e) {
70325       {
70326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70327       };
70328     } catch (...) {
70329       {
70330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70331       };
70332     }
70333   }
70334
70335   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70336   return jresult;
70337 }
70338
70339
70340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70341   int jresult ;
70342   int result;
70343
70344   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70345   jresult = (int)result;
70346   return jresult;
70347 }
70348
70349
70350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70351   int jresult ;
70352   int result;
70353
70354   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70355   jresult = (int)result;
70356   return jresult;
70357 }
70358
70359
70360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70361   int jresult ;
70362   int result;
70363
70364   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70365   jresult = (int)result;
70366   return jresult;
70367 }
70368
70369
70370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70371   int jresult ;
70372   int result;
70373
70374   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70375   jresult = (int)result;
70376   return jresult;
70377 }
70378
70379
70380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70381   int jresult ;
70382   int result;
70383
70384   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70385   jresult = (int)result;
70386   return jresult;
70387 }
70388
70389
70390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70391   void * jresult ;
70392   Dali::Toolkit::PushButton::Property *result = 0 ;
70393
70394   {
70395     try {
70396       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70397     } catch (std::out_of_range& e) {
70398       {
70399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70400       };
70401     } catch (std::exception& e) {
70402       {
70403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70404       };
70405     } catch (Dali::DaliException e) {
70406       {
70407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70408       };
70409     } catch (...) {
70410       {
70411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70412       };
70413     }
70414   }
70415
70416   jresult = (void *)result;
70417   return jresult;
70418 }
70419
70420
70421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70422   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70423
70424   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70425   {
70426     try {
70427       delete arg1;
70428     } catch (std::out_of_range& e) {
70429       {
70430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70431       };
70432     } catch (std::exception& e) {
70433       {
70434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70435       };
70436     } catch (Dali::DaliException e) {
70437       {
70438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70439       };
70440     } catch (...) {
70441       {
70442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70443       };
70444     }
70445   }
70446
70447 }
70448
70449
70450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70451   void * jresult ;
70452   Dali::Toolkit::PushButton *result = 0 ;
70453
70454   {
70455     try {
70456       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70457     } catch (std::out_of_range& e) {
70458       {
70459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70460       };
70461     } catch (std::exception& e) {
70462       {
70463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70464       };
70465     } catch (Dali::DaliException e) {
70466       {
70467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70468       };
70469     } catch (...) {
70470       {
70471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70472       };
70473     }
70474   }
70475
70476   jresult = (void *)result;
70477   return jresult;
70478 }
70479
70480
70481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70482   void * jresult ;
70483   Dali::Toolkit::PushButton *arg1 = 0 ;
70484   Dali::Toolkit::PushButton *result = 0 ;
70485
70486   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70487   if (!arg1) {
70488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70489     return 0;
70490   }
70491   {
70492     try {
70493       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70494     } catch (std::out_of_range& e) {
70495       {
70496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70497       };
70498     } catch (std::exception& e) {
70499       {
70500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70501       };
70502     } catch (Dali::DaliException e) {
70503       {
70504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70505       };
70506     } catch (...) {
70507       {
70508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70509       };
70510     }
70511   }
70512
70513   jresult = (void *)result;
70514   return jresult;
70515 }
70516
70517
70518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70519   void * jresult ;
70520   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70521   Dali::Toolkit::PushButton *arg2 = 0 ;
70522   Dali::Toolkit::PushButton *result = 0 ;
70523
70524   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70525   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70526   if (!arg2) {
70527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70528     return 0;
70529   }
70530   {
70531     try {
70532       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70533     } catch (std::out_of_range& e) {
70534       {
70535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70536       };
70537     } catch (std::exception& e) {
70538       {
70539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70540       };
70541     } catch (Dali::DaliException e) {
70542       {
70543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70544       };
70545     } catch (...) {
70546       {
70547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70548       };
70549     }
70550   }
70551
70552   jresult = (void *)result;
70553   return jresult;
70554 }
70555
70556
70557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70558   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70559
70560   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70561   {
70562     try {
70563       delete arg1;
70564     } catch (std::out_of_range& e) {
70565       {
70566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70567       };
70568     } catch (std::exception& e) {
70569       {
70570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70571       };
70572     } catch (Dali::DaliException e) {
70573       {
70574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70575       };
70576     } catch (...) {
70577       {
70578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70579       };
70580     }
70581   }
70582
70583 }
70584
70585
70586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70587   void * jresult ;
70588   Dali::Toolkit::PushButton result;
70589
70590   {
70591     try {
70592       result = Dali::Toolkit::PushButton::New();
70593     } catch (std::out_of_range& e) {
70594       {
70595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70596       };
70597     } catch (std::exception& e) {
70598       {
70599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70600       };
70601     } catch (Dali::DaliException e) {
70602       {
70603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70604       };
70605     } catch (...) {
70606       {
70607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70608       };
70609     }
70610   }
70611
70612   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70613   return jresult;
70614 }
70615
70616
70617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70618   void * jresult ;
70619   Dali::BaseHandle arg1 ;
70620   Dali::BaseHandle *argp1 ;
70621   Dali::Toolkit::PushButton result;
70622
70623   argp1 = (Dali::BaseHandle *)jarg1;
70624   if (!argp1) {
70625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70626     return 0;
70627   }
70628   arg1 = *argp1;
70629   {
70630     try {
70631       result = Dali::Toolkit::PushButton::DownCast(arg1);
70632     } catch (std::out_of_range& e) {
70633       {
70634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70635       };
70636     } catch (std::exception& e) {
70637       {
70638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70639       };
70640     } catch (Dali::DaliException e) {
70641       {
70642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70643       };
70644     } catch (...) {
70645       {
70646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70647       };
70648     }
70649   }
70650
70651   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70652   return jresult;
70653 }
70654
70655
70656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70657   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70658   Dali::Image arg2 ;
70659   Dali::Image *argp2 ;
70660
70661   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70662   argp2 = (Dali::Image *)jarg2;
70663   if (!argp2) {
70664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70665     return ;
70666   }
70667   arg2 = *argp2;
70668   {
70669     try {
70670       (arg1)->SetButtonImage(arg2);
70671     } catch (std::out_of_range& e) {
70672       {
70673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70674       };
70675     } catch (std::exception& e) {
70676       {
70677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70678       };
70679     } catch (Dali::DaliException e) {
70680       {
70681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70682       };
70683     } catch (...) {
70684       {
70685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70686       };
70687     }
70688   }
70689
70690 }
70691
70692
70693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70694   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70695   Dali::Actor arg2 ;
70696   Dali::Actor *argp2 ;
70697
70698   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70699   argp2 = (Dali::Actor *)jarg2;
70700   if (!argp2) {
70701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70702     return ;
70703   }
70704   arg2 = *argp2;
70705   {
70706     try {
70707       (arg1)->SetButtonImage(arg2);
70708     } catch (std::out_of_range& e) {
70709       {
70710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70711       };
70712     } catch (std::exception& e) {
70713       {
70714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70715       };
70716     } catch (Dali::DaliException e) {
70717       {
70718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70719       };
70720     } catch (...) {
70721       {
70722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70723       };
70724     }
70725   }
70726
70727 }
70728
70729
70730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70731   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70732   Dali::Actor arg2 ;
70733   Dali::Actor *argp2 ;
70734
70735   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70736   argp2 = (Dali::Actor *)jarg2;
70737   if (!argp2) {
70738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70739     return ;
70740   }
70741   arg2 = *argp2;
70742   {
70743     try {
70744       (arg1)->SetBackgroundImage(arg2);
70745     } catch (std::out_of_range& e) {
70746       {
70747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70748       };
70749     } catch (std::exception& e) {
70750       {
70751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70752       };
70753     } catch (Dali::DaliException e) {
70754       {
70755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70756       };
70757     } catch (...) {
70758       {
70759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70760       };
70761     }
70762   }
70763
70764 }
70765
70766
70767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70768   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70769   Dali::Image arg2 ;
70770   Dali::Image *argp2 ;
70771
70772   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70773   argp2 = (Dali::Image *)jarg2;
70774   if (!argp2) {
70775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70776     return ;
70777   }
70778   arg2 = *argp2;
70779   {
70780     try {
70781       (arg1)->SetSelectedImage(arg2);
70782     } catch (std::out_of_range& e) {
70783       {
70784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70785       };
70786     } catch (std::exception& e) {
70787       {
70788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70789       };
70790     } catch (Dali::DaliException e) {
70791       {
70792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70793       };
70794     } catch (...) {
70795       {
70796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70797       };
70798     }
70799   }
70800
70801 }
70802
70803
70804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70805   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70806   Dali::Actor arg2 ;
70807   Dali::Actor *argp2 ;
70808
70809   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70810   argp2 = (Dali::Actor *)jarg2;
70811   if (!argp2) {
70812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70813     return ;
70814   }
70815   arg2 = *argp2;
70816   {
70817     try {
70818       (arg1)->SetSelectedImage(arg2);
70819     } catch (std::out_of_range& e) {
70820       {
70821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70822       };
70823     } catch (std::exception& e) {
70824       {
70825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70826       };
70827     } catch (Dali::DaliException e) {
70828       {
70829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70830       };
70831     } catch (...) {
70832       {
70833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70834       };
70835     }
70836   }
70837
70838 }
70839
70840
70841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70842   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70843   Dali::Actor arg2 ;
70844   Dali::Actor *argp2 ;
70845
70846   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70847   argp2 = (Dali::Actor *)jarg2;
70848   if (!argp2) {
70849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70850     return ;
70851   }
70852   arg2 = *argp2;
70853   {
70854     try {
70855       (arg1)->SetSelectedBackgroundImage(arg2);
70856     } catch (std::out_of_range& e) {
70857       {
70858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70859       };
70860     } catch (std::exception& e) {
70861       {
70862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70863       };
70864     } catch (Dali::DaliException e) {
70865       {
70866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70867       };
70868     } catch (...) {
70869       {
70870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70871       };
70872     }
70873   }
70874
70875 }
70876
70877
70878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70879   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70880   Dali::Actor arg2 ;
70881   Dali::Actor *argp2 ;
70882
70883   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70884   argp2 = (Dali::Actor *)jarg2;
70885   if (!argp2) {
70886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70887     return ;
70888   }
70889   arg2 = *argp2;
70890   {
70891     try {
70892       (arg1)->SetDisabledBackgroundImage(arg2);
70893     } catch (std::out_of_range& e) {
70894       {
70895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70896       };
70897     } catch (std::exception& e) {
70898       {
70899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70900       };
70901     } catch (Dali::DaliException e) {
70902       {
70903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70904       };
70905     } catch (...) {
70906       {
70907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70908       };
70909     }
70910   }
70911
70912 }
70913
70914
70915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70916   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70917   Dali::Actor arg2 ;
70918   Dali::Actor *argp2 ;
70919
70920   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70921   argp2 = (Dali::Actor *)jarg2;
70922   if (!argp2) {
70923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70924     return ;
70925   }
70926   arg2 = *argp2;
70927   {
70928     try {
70929       (arg1)->SetDisabledImage(arg2);
70930     } catch (std::out_of_range& e) {
70931       {
70932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70933       };
70934     } catch (std::exception& e) {
70935       {
70936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70937       };
70938     } catch (Dali::DaliException e) {
70939       {
70940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70941       };
70942     } catch (...) {
70943       {
70944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70945       };
70946     }
70947   }
70948
70949 }
70950
70951
70952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70953   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70954   Dali::Actor arg2 ;
70955   Dali::Actor *argp2 ;
70956
70957   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70958   argp2 = (Dali::Actor *)jarg2;
70959   if (!argp2) {
70960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70961     return ;
70962   }
70963   arg2 = *argp2;
70964   {
70965     try {
70966       (arg1)->SetDisabledSelectedImage(arg2);
70967     } catch (std::out_of_range& e) {
70968       {
70969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70970       };
70971     } catch (std::exception& e) {
70972       {
70973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70974       };
70975     } catch (Dali::DaliException e) {
70976       {
70977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70978       };
70979     } catch (...) {
70980       {
70981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70982       };
70983     }
70984   }
70985
70986 }
70987
70988
70989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70990   void * jresult ;
70991   Dali::Toolkit::RadioButton *result = 0 ;
70992
70993   {
70994     try {
70995       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70996     } catch (std::out_of_range& e) {
70997       {
70998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70999       };
71000     } catch (std::exception& e) {
71001       {
71002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71003       };
71004     } catch (Dali::DaliException e) {
71005       {
71006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71007       };
71008     } catch (...) {
71009       {
71010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71011       };
71012     }
71013   }
71014
71015   jresult = (void *)result;
71016   return jresult;
71017 }
71018
71019
71020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71021   void * jresult ;
71022   Dali::Toolkit::RadioButton *arg1 = 0 ;
71023   Dali::Toolkit::RadioButton *result = 0 ;
71024
71025   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71026   if (!arg1) {
71027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71028     return 0;
71029   }
71030   {
71031     try {
71032       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71033     } catch (std::out_of_range& e) {
71034       {
71035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71036       };
71037     } catch (std::exception& e) {
71038       {
71039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71040       };
71041     } catch (Dali::DaliException e) {
71042       {
71043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71044       };
71045     } catch (...) {
71046       {
71047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71048       };
71049     }
71050   }
71051
71052   jresult = (void *)result;
71053   return jresult;
71054 }
71055
71056
71057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71058   void * jresult ;
71059   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71060   Dali::Toolkit::RadioButton *arg2 = 0 ;
71061   Dali::Toolkit::RadioButton *result = 0 ;
71062
71063   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71064   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71065   if (!arg2) {
71066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71067     return 0;
71068   }
71069   {
71070     try {
71071       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71072     } catch (std::out_of_range& e) {
71073       {
71074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71075       };
71076     } catch (std::exception& e) {
71077       {
71078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71079       };
71080     } catch (Dali::DaliException e) {
71081       {
71082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71083       };
71084     } catch (...) {
71085       {
71086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71087       };
71088     }
71089   }
71090
71091   jresult = (void *)result;
71092   return jresult;
71093 }
71094
71095
71096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71097   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71098
71099   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71100   {
71101     try {
71102       delete arg1;
71103     } catch (std::out_of_range& e) {
71104       {
71105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71106       };
71107     } catch (std::exception& e) {
71108       {
71109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71110       };
71111     } catch (Dali::DaliException e) {
71112       {
71113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71114       };
71115     } catch (...) {
71116       {
71117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71118       };
71119     }
71120   }
71121
71122 }
71123
71124
71125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71126   void * jresult ;
71127   Dali::Toolkit::RadioButton result;
71128
71129   {
71130     try {
71131       result = Dali::Toolkit::RadioButton::New();
71132     } catch (std::out_of_range& e) {
71133       {
71134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71135       };
71136     } catch (std::exception& e) {
71137       {
71138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71139       };
71140     } catch (Dali::DaliException e) {
71141       {
71142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71143       };
71144     } catch (...) {
71145       {
71146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71147       };
71148     }
71149   }
71150
71151   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71152   return jresult;
71153 }
71154
71155
71156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71157   void * jresult ;
71158   std::string *arg1 = 0 ;
71159   Dali::Toolkit::RadioButton result;
71160
71161   if (!jarg1) {
71162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71163     return 0;
71164   }
71165   std::string arg1_str(jarg1);
71166   arg1 = &arg1_str;
71167   {
71168     try {
71169       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71170     } catch (std::out_of_range& e) {
71171       {
71172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71173       };
71174     } catch (std::exception& e) {
71175       {
71176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71177       };
71178     } catch (Dali::DaliException e) {
71179       {
71180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71181       };
71182     } catch (...) {
71183       {
71184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71185       };
71186     }
71187   }
71188
71189   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71190
71191   //argout typemap for const std::string&
71192
71193   return jresult;
71194 }
71195
71196
71197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71198   void * jresult ;
71199   Dali::BaseHandle arg1 ;
71200   Dali::BaseHandle *argp1 ;
71201   Dali::Toolkit::RadioButton result;
71202
71203   argp1 = (Dali::BaseHandle *)jarg1;
71204   if (!argp1) {
71205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71206     return 0;
71207   }
71208   arg1 = *argp1;
71209   {
71210     try {
71211       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71212     } catch (std::out_of_range& e) {
71213       {
71214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71215       };
71216     } catch (std::exception& e) {
71217       {
71218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71219       };
71220     } catch (Dali::DaliException e) {
71221       {
71222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71223       };
71224     } catch (...) {
71225       {
71226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71227       };
71228     }
71229   }
71230
71231   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71232   return jresult;
71233 }
71234
71235
71236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71237   int jresult ;
71238   int result;
71239
71240   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71241   jresult = (int)result;
71242   return jresult;
71243 }
71244
71245
71246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71247   int jresult ;
71248   int result;
71249
71250   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71251   jresult = (int)result;
71252   return jresult;
71253 }
71254
71255
71256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71257   int jresult ;
71258   int result;
71259
71260   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71261   jresult = (int)result;
71262   return jresult;
71263 }
71264
71265
71266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71267   int jresult ;
71268   int result;
71269
71270   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71271   jresult = (int)result;
71272   return jresult;
71273 }
71274
71275
71276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71277   int jresult ;
71278   int result;
71279
71280   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71281   jresult = (int)result;
71282   return jresult;
71283 }
71284
71285
71286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71287   int jresult ;
71288   int result;
71289
71290   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71291   jresult = (int)result;
71292   return jresult;
71293 }
71294
71295
71296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71297   void * jresult ;
71298   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71299
71300   {
71301     try {
71302       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71303     } catch (std::out_of_range& e) {
71304       {
71305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71306       };
71307     } catch (std::exception& e) {
71308       {
71309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71310       };
71311     } catch (Dali::DaliException e) {
71312       {
71313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71314       };
71315     } catch (...) {
71316       {
71317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71318       };
71319     }
71320   }
71321
71322   jresult = (void *)result;
71323   return jresult;
71324 }
71325
71326
71327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71328   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71329
71330   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71331   {
71332     try {
71333       delete arg1;
71334     } catch (std::out_of_range& e) {
71335       {
71336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71337       };
71338     } catch (std::exception& e) {
71339       {
71340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71341       };
71342     } catch (Dali::DaliException e) {
71343       {
71344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71345       };
71346     } catch (...) {
71347       {
71348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71349       };
71350     }
71351   }
71352
71353 }
71354
71355
71356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71357   int jresult ;
71358   int result;
71359
71360   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71361   jresult = (int)result;
71362   return jresult;
71363 }
71364
71365
71366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71367   int jresult ;
71368   int result;
71369
71370   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71371   jresult = (int)result;
71372   return jresult;
71373 }
71374
71375
71376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71377   int jresult ;
71378   int result;
71379
71380   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71381   jresult = (int)result;
71382   return jresult;
71383 }
71384
71385
71386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71387   void * jresult ;
71388   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71389
71390   {
71391     try {
71392       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71393     } catch (std::out_of_range& e) {
71394       {
71395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71396       };
71397     } catch (std::exception& e) {
71398       {
71399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71400       };
71401     } catch (Dali::DaliException e) {
71402       {
71403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71404       };
71405     } catch (...) {
71406       {
71407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71408       };
71409     }
71410   }
71411
71412   jresult = (void *)result;
71413   return jresult;
71414 }
71415
71416
71417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71418   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71419
71420   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71421   {
71422     try {
71423       delete arg1;
71424     } catch (std::out_of_range& e) {
71425       {
71426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71427       };
71428     } catch (std::exception& e) {
71429       {
71430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71431       };
71432     } catch (Dali::DaliException e) {
71433       {
71434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71435       };
71436     } catch (...) {
71437       {
71438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71439       };
71440     }
71441   }
71442
71443 }
71444
71445
71446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71447   void * jresult ;
71448   Dali::Toolkit::FlexContainer *result = 0 ;
71449
71450   {
71451     try {
71452       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71453     } catch (std::out_of_range& e) {
71454       {
71455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71456       };
71457     } catch (std::exception& e) {
71458       {
71459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71460       };
71461     } catch (Dali::DaliException e) {
71462       {
71463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71464       };
71465     } catch (...) {
71466       {
71467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71468       };
71469     }
71470   }
71471
71472   jresult = (void *)result;
71473   return jresult;
71474 }
71475
71476
71477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71478   void * jresult ;
71479   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71480   Dali::Toolkit::FlexContainer *result = 0 ;
71481
71482   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71483   if (!arg1) {
71484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71485     return 0;
71486   }
71487   {
71488     try {
71489       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71490     } catch (std::out_of_range& e) {
71491       {
71492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71493       };
71494     } catch (std::exception& e) {
71495       {
71496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71497       };
71498     } catch (Dali::DaliException e) {
71499       {
71500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71501       };
71502     } catch (...) {
71503       {
71504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71505       };
71506     }
71507   }
71508
71509   jresult = (void *)result;
71510   return jresult;
71511 }
71512
71513
71514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71515   void * jresult ;
71516   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71517   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71518   Dali::Toolkit::FlexContainer *result = 0 ;
71519
71520   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71521   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71522   if (!arg2) {
71523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71524     return 0;
71525   }
71526   {
71527     try {
71528       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71529     } catch (std::out_of_range& e) {
71530       {
71531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71532       };
71533     } catch (std::exception& e) {
71534       {
71535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71536       };
71537     } catch (Dali::DaliException e) {
71538       {
71539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71540       };
71541     } catch (...) {
71542       {
71543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71544       };
71545     }
71546   }
71547
71548   jresult = (void *)result;
71549   return jresult;
71550 }
71551
71552
71553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71554   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71555
71556   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71557   {
71558     try {
71559       delete arg1;
71560     } catch (std::out_of_range& e) {
71561       {
71562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71563       };
71564     } catch (std::exception& e) {
71565       {
71566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71567       };
71568     } catch (Dali::DaliException e) {
71569       {
71570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71571       };
71572     } catch (...) {
71573       {
71574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71575       };
71576     }
71577   }
71578
71579 }
71580
71581
71582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71583   void * jresult ;
71584   Dali::Toolkit::FlexContainer result;
71585
71586   {
71587     try {
71588       result = Dali::Toolkit::FlexContainer::New();
71589     } catch (std::out_of_range& e) {
71590       {
71591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71592       };
71593     } catch (std::exception& e) {
71594       {
71595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71596       };
71597     } catch (Dali::DaliException e) {
71598       {
71599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71600       };
71601     } catch (...) {
71602       {
71603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71604       };
71605     }
71606   }
71607
71608   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71609   return jresult;
71610 }
71611
71612
71613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71614   void * jresult ;
71615   Dali::BaseHandle arg1 ;
71616   Dali::BaseHandle *argp1 ;
71617   Dali::Toolkit::FlexContainer result;
71618
71619   argp1 = (Dali::BaseHandle *)jarg1;
71620   if (!argp1) {
71621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71622     return 0;
71623   }
71624   arg1 = *argp1;
71625   {
71626     try {
71627       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71628     } catch (std::out_of_range& e) {
71629       {
71630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71631       };
71632     } catch (std::exception& e) {
71633       {
71634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71635       };
71636     } catch (Dali::DaliException e) {
71637       {
71638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71639       };
71640     } catch (...) {
71641       {
71642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71643       };
71644     }
71645   }
71646
71647   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71648   return jresult;
71649 }
71650
71651
71652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71653   int jresult ;
71654   int result;
71655
71656   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71657   jresult = (int)result;
71658   return jresult;
71659 }
71660
71661
71662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71663   int jresult ;
71664   int result;
71665
71666   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71667   jresult = (int)result;
71668   return jresult;
71669 }
71670
71671
71672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71673   int jresult ;
71674   int result;
71675
71676   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71677   jresult = (int)result;
71678   return jresult;
71679 }
71680
71681
71682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71683   int jresult ;
71684   int result;
71685
71686   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71687   jresult = (int)result;
71688   return jresult;
71689 }
71690
71691
71692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71693   void * jresult ;
71694   Dali::Toolkit::ImageView::Property *result = 0 ;
71695
71696   {
71697     try {
71698       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71699     } catch (std::out_of_range& e) {
71700       {
71701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71702       };
71703     } catch (std::exception& e) {
71704       {
71705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71706       };
71707     } catch (Dali::DaliException e) {
71708       {
71709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71710       };
71711     } catch (...) {
71712       {
71713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71714       };
71715     }
71716   }
71717
71718   jresult = (void *)result;
71719   return jresult;
71720 }
71721
71722
71723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71724   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71725
71726   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71727   {
71728     try {
71729       delete arg1;
71730     } catch (std::out_of_range& e) {
71731       {
71732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71733       };
71734     } catch (std::exception& e) {
71735       {
71736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71737       };
71738     } catch (Dali::DaliException e) {
71739       {
71740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71741       };
71742     } catch (...) {
71743       {
71744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71745       };
71746     }
71747   }
71748
71749 }
71750
71751
71752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71753   void * jresult ;
71754   Dali::Toolkit::ImageView *result = 0 ;
71755
71756   {
71757     try {
71758       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71759     } catch (std::out_of_range& e) {
71760       {
71761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71762       };
71763     } catch (std::exception& e) {
71764       {
71765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71766       };
71767     } catch (Dali::DaliException e) {
71768       {
71769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71770       };
71771     } catch (...) {
71772       {
71773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71774       };
71775     }
71776   }
71777
71778   jresult = (void *)result;
71779   return jresult;
71780 }
71781
71782
71783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71784   void * jresult ;
71785   Dali::Toolkit::ImageView result;
71786
71787   {
71788     try {
71789       result = Dali::Toolkit::ImageView::New();
71790     } catch (std::out_of_range& e) {
71791       {
71792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71793       };
71794     } catch (std::exception& e) {
71795       {
71796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71797       };
71798     } catch (Dali::DaliException e) {
71799       {
71800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71801       };
71802     } catch (...) {
71803       {
71804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71805       };
71806     }
71807   }
71808
71809   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71810   return jresult;
71811 }
71812
71813
71814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71815   void * jresult ;
71816   Dali::Image arg1 ;
71817   Dali::Image *argp1 ;
71818   Dali::Toolkit::ImageView result;
71819
71820   argp1 = (Dali::Image *)jarg1;
71821   if (!argp1) {
71822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71823     return 0;
71824   }
71825   arg1 = *argp1;
71826   {
71827     try {
71828       result = Dali::Toolkit::ImageView::New(arg1);
71829     } catch (std::out_of_range& e) {
71830       {
71831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71832       };
71833     } catch (std::exception& e) {
71834       {
71835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71836       };
71837     } catch (Dali::DaliException e) {
71838       {
71839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71840       };
71841     } catch (...) {
71842       {
71843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71844       };
71845     }
71846   }
71847
71848   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71849   return jresult;
71850 }
71851
71852
71853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71854   void * jresult ;
71855   std::string *arg1 = 0 ;
71856   Dali::Toolkit::ImageView result;
71857
71858   if (!jarg1) {
71859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71860     return 0;
71861   }
71862   std::string arg1_str(jarg1);
71863   arg1 = &arg1_str;
71864   {
71865     try {
71866       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71867     } catch (std::out_of_range& e) {
71868       {
71869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71870       };
71871     } catch (std::exception& e) {
71872       {
71873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71874       };
71875     } catch (Dali::DaliException e) {
71876       {
71877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71878       };
71879     } catch (...) {
71880       {
71881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71882       };
71883     }
71884   }
71885
71886   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71887
71888   //argout typemap for const std::string&
71889
71890   return jresult;
71891 }
71892
71893
71894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71895   void * jresult ;
71896   std::string *arg1 = 0 ;
71897   Dali::ImageDimensions arg2 ;
71898   Dali::ImageDimensions *argp2 ;
71899   Dali::Toolkit::ImageView result;
71900
71901   if (!jarg1) {
71902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71903     return 0;
71904   }
71905   std::string arg1_str(jarg1);
71906   arg1 = &arg1_str;
71907   argp2 = (Dali::ImageDimensions *)jarg2;
71908   if (!argp2) {
71909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71910     return 0;
71911   }
71912   arg2 = *argp2;
71913   {
71914     try {
71915       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71916     } catch (std::out_of_range& e) {
71917       {
71918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71919       };
71920     } catch (std::exception& e) {
71921       {
71922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71923       };
71924     } catch (Dali::DaliException e) {
71925       {
71926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71927       };
71928     } catch (...) {
71929       {
71930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71931       };
71932     }
71933   }
71934
71935   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71936
71937   //argout typemap for const std::string&
71938
71939   return jresult;
71940 }
71941
71942
71943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71944   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71945
71946   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71947   {
71948     try {
71949       delete arg1;
71950     } catch (std::out_of_range& e) {
71951       {
71952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71953       };
71954     } catch (std::exception& e) {
71955       {
71956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71957       };
71958     } catch (Dali::DaliException e) {
71959       {
71960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71961       };
71962     } catch (...) {
71963       {
71964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71965       };
71966     }
71967   }
71968
71969 }
71970
71971
71972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71973   void * jresult ;
71974   Dali::Toolkit::ImageView *arg1 = 0 ;
71975   Dali::Toolkit::ImageView *result = 0 ;
71976
71977   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71978   if (!arg1) {
71979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71980     return 0;
71981   }
71982   {
71983     try {
71984       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71985     } catch (std::out_of_range& e) {
71986       {
71987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71988       };
71989     } catch (std::exception& e) {
71990       {
71991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71992       };
71993     } catch (Dali::DaliException e) {
71994       {
71995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71996       };
71997     } catch (...) {
71998       {
71999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72000       };
72001     }
72002   }
72003
72004   jresult = (void *)result;
72005   return jresult;
72006 }
72007
72008
72009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72010   void * jresult ;
72011   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72012   Dali::Toolkit::ImageView *arg2 = 0 ;
72013   Dali::Toolkit::ImageView *result = 0 ;
72014
72015   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72016   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72017   if (!arg2) {
72018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72019     return 0;
72020   }
72021   {
72022     try {
72023       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72024     } catch (std::out_of_range& e) {
72025       {
72026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72027       };
72028     } catch (std::exception& e) {
72029       {
72030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72031       };
72032     } catch (Dali::DaliException e) {
72033       {
72034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72035       };
72036     } catch (...) {
72037       {
72038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72039       };
72040     }
72041   }
72042
72043   jresult = (void *)result;
72044   return jresult;
72045 }
72046
72047
72048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72049   void * jresult ;
72050   Dali::BaseHandle arg1 ;
72051   Dali::BaseHandle *argp1 ;
72052   Dali::Toolkit::ImageView result;
72053
72054   argp1 = (Dali::BaseHandle *)jarg1;
72055   if (!argp1) {
72056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72057     return 0;
72058   }
72059   arg1 = *argp1;
72060   {
72061     try {
72062       result = Dali::Toolkit::ImageView::DownCast(arg1);
72063     } catch (std::out_of_range& e) {
72064       {
72065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72066       };
72067     } catch (std::exception& e) {
72068       {
72069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72070       };
72071     } catch (Dali::DaliException e) {
72072       {
72073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72074       };
72075     } catch (...) {
72076       {
72077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72078       };
72079     }
72080   }
72081
72082   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72083   return jresult;
72084 }
72085
72086
72087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72088   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72089   Dali::Image arg2 ;
72090   Dali::Image *argp2 ;
72091
72092   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72093   argp2 = (Dali::Image *)jarg2;
72094   if (!argp2) {
72095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72096     return ;
72097   }
72098   arg2 = *argp2;
72099   {
72100     try {
72101       (arg1)->SetImage(arg2);
72102     } catch (std::out_of_range& e) {
72103       {
72104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72105       };
72106     } catch (std::exception& e) {
72107       {
72108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72109       };
72110     } catch (Dali::DaliException e) {
72111       {
72112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72113       };
72114     } catch (...) {
72115       {
72116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72117       };
72118     }
72119   }
72120
72121 }
72122
72123
72124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72125   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72126   std::string *arg2 = 0 ;
72127
72128   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72129   if (!jarg2) {
72130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72131     return ;
72132   }
72133   std::string arg2_str(jarg2);
72134   arg2 = &arg2_str;
72135   {
72136     try {
72137       (arg1)->SetImage((std::string const &)*arg2);
72138     } catch (std::out_of_range& e) {
72139       {
72140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72141       };
72142     } catch (std::exception& e) {
72143       {
72144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72145       };
72146     } catch (Dali::DaliException e) {
72147       {
72148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72149       };
72150     } catch (...) {
72151       {
72152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72153       };
72154     }
72155   }
72156
72157
72158   //argout typemap for const std::string&
72159
72160 }
72161
72162
72163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72164   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72165   std::string *arg2 = 0 ;
72166   Dali::ImageDimensions arg3 ;
72167   Dali::ImageDimensions *argp3 ;
72168
72169   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72170   if (!jarg2) {
72171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72172     return ;
72173   }
72174   std::string arg2_str(jarg2);
72175   arg2 = &arg2_str;
72176   argp3 = (Dali::ImageDimensions *)jarg3;
72177   if (!argp3) {
72178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72179     return ;
72180   }
72181   arg3 = *argp3;
72182   {
72183     try {
72184       (arg1)->SetImage((std::string const &)*arg2,arg3);
72185     } catch (std::out_of_range& e) {
72186       {
72187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72188       };
72189     } catch (std::exception& e) {
72190       {
72191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72192       };
72193     } catch (Dali::DaliException e) {
72194       {
72195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72196       };
72197     } catch (...) {
72198       {
72199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72200       };
72201     }
72202   }
72203
72204
72205   //argout typemap for const std::string&
72206
72207 }
72208
72209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72210   void * jresult ;
72211   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72212   Dali::Image result;
72213
72214   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72215   {
72216     try {
72217       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72218     } catch (std::out_of_range& e) {
72219       {
72220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72221       };
72222     } catch (std::exception& e) {
72223       {
72224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72225       };
72226     } catch (Dali::DaliException e) {
72227       {
72228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72229       };
72230     } catch (...) {
72231       {
72232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72233       };
72234     }
72235   }
72236
72237   jresult = new Dali::Image((const Dali::Image &)result);
72238   return jresult;
72239 }
72240
72241
72242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72243   int jresult ;
72244   int result;
72245
72246   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72247   jresult = (int)result;
72248   return jresult;
72249 }
72250
72251
72252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72253   int jresult ;
72254   int result;
72255
72256   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72257   jresult = (int)result;
72258   return jresult;
72259 }
72260
72261
72262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72263   int jresult ;
72264   int result;
72265
72266   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72267   jresult = (int)result;
72268   return jresult;
72269 }
72270
72271
72272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72273   int jresult ;
72274   int result;
72275
72276   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72277   jresult = (int)result;
72278   return jresult;
72279 }
72280
72281
72282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72283   int jresult ;
72284   int result;
72285
72286   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72287   jresult = (int)result;
72288   return jresult;
72289 }
72290
72291
72292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72293   int jresult ;
72294   int result;
72295
72296   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72297   jresult = (int)result;
72298   return jresult;
72299 }
72300
72301
72302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72303   int jresult ;
72304   int result;
72305
72306   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72307   jresult = (int)result;
72308   return jresult;
72309 }
72310
72311
72312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72313   int jresult ;
72314   int result;
72315
72316   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72317   jresult = (int)result;
72318   return jresult;
72319 }
72320
72321
72322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72323   void * jresult ;
72324   Dali::Toolkit::Model3dView::Property *result = 0 ;
72325
72326   {
72327     try {
72328       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72329     } catch (std::out_of_range& e) {
72330       {
72331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72332       };
72333     } catch (std::exception& e) {
72334       {
72335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72336       };
72337     } catch (Dali::DaliException e) {
72338       {
72339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72340       };
72341     } catch (...) {
72342       {
72343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72344       };
72345     }
72346   }
72347
72348   jresult = (void *)result;
72349   return jresult;
72350 }
72351
72352
72353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72354   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72355
72356   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72357   {
72358     try {
72359       delete arg1;
72360     } catch (std::out_of_range& e) {
72361       {
72362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72363       };
72364     } catch (std::exception& e) {
72365       {
72366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72367       };
72368     } catch (Dali::DaliException e) {
72369       {
72370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72371       };
72372     } catch (...) {
72373       {
72374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72375       };
72376     }
72377   }
72378
72379 }
72380
72381
72382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72383   void * jresult ;
72384   Dali::Toolkit::Model3dView result;
72385
72386   {
72387     try {
72388       result = Dali::Toolkit::Model3dView::New();
72389     } catch (std::out_of_range& e) {
72390       {
72391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72392       };
72393     } catch (std::exception& e) {
72394       {
72395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72396       };
72397     } catch (Dali::DaliException e) {
72398       {
72399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72400       };
72401     } catch (...) {
72402       {
72403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72404       };
72405     }
72406   }
72407
72408   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72409   return jresult;
72410 }
72411
72412
72413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72414   void * jresult ;
72415   std::string *arg1 = 0 ;
72416   std::string *arg2 = 0 ;
72417   std::string *arg3 = 0 ;
72418   Dali::Toolkit::Model3dView result;
72419
72420   if (!jarg1) {
72421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72422     return 0;
72423   }
72424   std::string arg1_str(jarg1);
72425   arg1 = &arg1_str;
72426   if (!jarg2) {
72427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72428     return 0;
72429   }
72430   std::string arg2_str(jarg2);
72431   arg2 = &arg2_str;
72432   if (!jarg3) {
72433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72434     return 0;
72435   }
72436   std::string arg3_str(jarg3);
72437   arg3 = &arg3_str;
72438   {
72439     try {
72440       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72441     } catch (std::out_of_range& e) {
72442       {
72443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72444       };
72445     } catch (std::exception& e) {
72446       {
72447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72448       };
72449     } catch (Dali::DaliException e) {
72450       {
72451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72452       };
72453     } catch (...) {
72454       {
72455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72456       };
72457     }
72458   }
72459
72460   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72461
72462   //argout typemap for const std::string&
72463
72464
72465   //argout typemap for const std::string&
72466
72467
72468   //argout typemap for const std::string&
72469
72470   return jresult;
72471 }
72472
72473
72474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72475   void * jresult ;
72476   Dali::Toolkit::Model3dView *result = 0 ;
72477
72478   {
72479     try {
72480       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72481     } catch (std::out_of_range& e) {
72482       {
72483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72484       };
72485     } catch (std::exception& e) {
72486       {
72487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72488       };
72489     } catch (Dali::DaliException e) {
72490       {
72491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72492       };
72493     } catch (...) {
72494       {
72495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72496       };
72497     }
72498   }
72499
72500   jresult = (void *)result;
72501   return jresult;
72502 }
72503
72504
72505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72506   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72507
72508   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72509   {
72510     try {
72511       delete arg1;
72512     } catch (std::out_of_range& e) {
72513       {
72514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72515       };
72516     } catch (std::exception& e) {
72517       {
72518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72519       };
72520     } catch (Dali::DaliException e) {
72521       {
72522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72523       };
72524     } catch (...) {
72525       {
72526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72527       };
72528     }
72529   }
72530
72531 }
72532
72533
72534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72535   void * jresult ;
72536   Dali::Toolkit::Model3dView *arg1 = 0 ;
72537   Dali::Toolkit::Model3dView *result = 0 ;
72538
72539   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72540   if (!arg1) {
72541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72542     return 0;
72543   }
72544   {
72545     try {
72546       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72547     } catch (std::out_of_range& e) {
72548       {
72549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72550       };
72551     } catch (std::exception& e) {
72552       {
72553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72554       };
72555     } catch (Dali::DaliException e) {
72556       {
72557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72558       };
72559     } catch (...) {
72560       {
72561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72562       };
72563     }
72564   }
72565
72566   jresult = (void *)result;
72567   return jresult;
72568 }
72569
72570
72571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72572   void * jresult ;
72573   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72574   Dali::Toolkit::Model3dView *arg2 = 0 ;
72575   Dali::Toolkit::Model3dView *result = 0 ;
72576
72577   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72578   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72579   if (!arg2) {
72580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72581     return 0;
72582   }
72583   {
72584     try {
72585       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72586     } catch (std::out_of_range& e) {
72587       {
72588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72589       };
72590     } catch (std::exception& e) {
72591       {
72592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72593       };
72594     } catch (Dali::DaliException e) {
72595       {
72596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72597       };
72598     } catch (...) {
72599       {
72600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72601       };
72602     }
72603   }
72604
72605   jresult = (void *)result;
72606   return jresult;
72607 }
72608
72609
72610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72611   void * jresult ;
72612   Dali::BaseHandle arg1 ;
72613   Dali::BaseHandle *argp1 ;
72614   Dali::Toolkit::Model3dView result;
72615
72616   argp1 = (Dali::BaseHandle *)jarg1;
72617   if (!argp1) {
72618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72619     return 0;
72620   }
72621   arg1 = *argp1;
72622   {
72623     try {
72624       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72625     } catch (std::out_of_range& e) {
72626       {
72627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72628       };
72629     } catch (std::exception& e) {
72630       {
72631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72632       };
72633     } catch (Dali::DaliException e) {
72634       {
72635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72636       };
72637     } catch (...) {
72638       {
72639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72640       };
72641     }
72642   }
72643
72644   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72645   return jresult;
72646 }
72647
72648
72649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72650   int jresult ;
72651   int result;
72652
72653   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72654   jresult = (int)result;
72655   return jresult;
72656 }
72657
72658
72659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72660   int jresult ;
72661   int result;
72662
72663   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72664   jresult = (int)result;
72665   return jresult;
72666 }
72667
72668
72669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72670   int jresult ;
72671   int result;
72672
72673   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72674   jresult = (int)result;
72675   return jresult;
72676 }
72677
72678
72679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72680   int jresult ;
72681   int result;
72682
72683   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72684   jresult = (int)result;
72685   return jresult;
72686 }
72687
72688
72689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72690   int jresult ;
72691   int result;
72692
72693   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72694   jresult = (int)result;
72695   return jresult;
72696 }
72697
72698
72699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72700   int jresult ;
72701   int result;
72702
72703   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72704   jresult = (int)result;
72705   return jresult;
72706 }
72707
72708
72709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72710   int jresult ;
72711   int result;
72712
72713   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72714   jresult = (int)result;
72715   return jresult;
72716 }
72717
72718
72719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72720   int jresult ;
72721   int result;
72722
72723   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72724   jresult = (int)result;
72725   return jresult;
72726 }
72727
72728
72729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72730   int jresult ;
72731   int result;
72732
72733   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72734   jresult = (int)result;
72735   return jresult;
72736 }
72737
72738
72739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72740   void * jresult ;
72741   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72742
72743   {
72744     try {
72745       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72746     } catch (std::out_of_range& e) {
72747       {
72748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72749       };
72750     } catch (std::exception& e) {
72751       {
72752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72753       };
72754     } catch (Dali::DaliException e) {
72755       {
72756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72757       };
72758     } catch (...) {
72759       {
72760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72761       };
72762     }
72763   }
72764
72765   jresult = (void *)result;
72766   return jresult;
72767 }
72768
72769
72770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72771   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72772
72773   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72774   {
72775     try {
72776       delete arg1;
72777     } catch (std::out_of_range& e) {
72778       {
72779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72780       };
72781     } catch (std::exception& e) {
72782       {
72783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72784       };
72785     } catch (Dali::DaliException e) {
72786       {
72787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72788       };
72789     } catch (...) {
72790       {
72791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72792       };
72793     }
72794   }
72795
72796 }
72797
72798
72799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72800   void * jresult ;
72801   Dali::Toolkit::ScrollBar *result = 0 ;
72802
72803   {
72804     try {
72805       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72806     } catch (std::out_of_range& e) {
72807       {
72808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72809       };
72810     } catch (std::exception& e) {
72811       {
72812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72813       };
72814     } catch (Dali::DaliException e) {
72815       {
72816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72817       };
72818     } catch (...) {
72819       {
72820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72821       };
72822     }
72823   }
72824
72825   jresult = (void *)result;
72826   return jresult;
72827 }
72828
72829
72830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72831   void * jresult ;
72832   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72833   Dali::Toolkit::ScrollBar *result = 0 ;
72834
72835   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72836   if (!arg1) {
72837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72838     return 0;
72839   }
72840   {
72841     try {
72842       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72843     } catch (std::out_of_range& e) {
72844       {
72845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72846       };
72847     } catch (std::exception& e) {
72848       {
72849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72850       };
72851     } catch (Dali::DaliException e) {
72852       {
72853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72854       };
72855     } catch (...) {
72856       {
72857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72858       };
72859     }
72860   }
72861
72862   jresult = (void *)result;
72863   return jresult;
72864 }
72865
72866
72867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72868   void * jresult ;
72869   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72870   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72871   Dali::Toolkit::ScrollBar *result = 0 ;
72872
72873   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72874   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72875   if (!arg2) {
72876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72877     return 0;
72878   }
72879   {
72880     try {
72881       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72882     } catch (std::out_of_range& e) {
72883       {
72884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72885       };
72886     } catch (std::exception& e) {
72887       {
72888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72889       };
72890     } catch (Dali::DaliException e) {
72891       {
72892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72893       };
72894     } catch (...) {
72895       {
72896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72897       };
72898     }
72899   }
72900
72901   jresult = (void *)result;
72902   return jresult;
72903 }
72904
72905
72906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72907   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72908
72909   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72910   {
72911     try {
72912       delete arg1;
72913     } catch (std::out_of_range& e) {
72914       {
72915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72916       };
72917     } catch (std::exception& e) {
72918       {
72919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72920       };
72921     } catch (Dali::DaliException e) {
72922       {
72923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72924       };
72925     } catch (...) {
72926       {
72927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72928       };
72929     }
72930   }
72931
72932 }
72933
72934
72935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72936   void * jresult ;
72937   Dali::Toolkit::ScrollBar::Direction arg1 ;
72938   Dali::Toolkit::ScrollBar result;
72939
72940   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72941   {
72942     try {
72943       result = Dali::Toolkit::ScrollBar::New(arg1);
72944     } catch (std::out_of_range& e) {
72945       {
72946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72947       };
72948     } catch (std::exception& e) {
72949       {
72950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72951       };
72952     } catch (Dali::DaliException e) {
72953       {
72954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72955       };
72956     } catch (...) {
72957       {
72958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72959       };
72960     }
72961   }
72962
72963   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72964   return jresult;
72965 }
72966
72967
72968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72969   void * jresult ;
72970   Dali::Toolkit::ScrollBar result;
72971
72972   {
72973     try {
72974       result = Dali::Toolkit::ScrollBar::New();
72975     } catch (std::out_of_range& e) {
72976       {
72977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72978       };
72979     } catch (std::exception& e) {
72980       {
72981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72982       };
72983     } catch (Dali::DaliException e) {
72984       {
72985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72986       };
72987     } catch (...) {
72988       {
72989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72990       };
72991     }
72992   }
72993
72994   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72995   return jresult;
72996 }
72997
72998
72999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73000   void * jresult ;
73001   Dali::BaseHandle arg1 ;
73002   Dali::BaseHandle *argp1 ;
73003   Dali::Toolkit::ScrollBar result;
73004
73005   argp1 = (Dali::BaseHandle *)jarg1;
73006   if (!argp1) {
73007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73008     return 0;
73009   }
73010   arg1 = *argp1;
73011   {
73012     try {
73013       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73014     } catch (std::out_of_range& e) {
73015       {
73016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73017       };
73018     } catch (std::exception& e) {
73019       {
73020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73021       };
73022     } catch (Dali::DaliException e) {
73023       {
73024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73025       };
73026     } catch (...) {
73027       {
73028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73029       };
73030     }
73031   }
73032
73033   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73034   return jresult;
73035 }
73036
73037
73038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73039   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73040   Dali::Handle arg2 ;
73041   Dali::Property::Index arg3 ;
73042   Dali::Property::Index arg4 ;
73043   Dali::Property::Index arg5 ;
73044   Dali::Property::Index arg6 ;
73045   Dali::Handle *argp2 ;
73046
73047   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73048   argp2 = (Dali::Handle *)jarg2;
73049   if (!argp2) {
73050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73051     return ;
73052   }
73053   arg2 = *argp2;
73054   arg3 = (Dali::Property::Index)jarg3;
73055   arg4 = (Dali::Property::Index)jarg4;
73056   arg5 = (Dali::Property::Index)jarg5;
73057   arg6 = (Dali::Property::Index)jarg6;
73058   {
73059     try {
73060       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73061     } catch (std::out_of_range& e) {
73062       {
73063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73064       };
73065     } catch (std::exception& e) {
73066       {
73067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73068       };
73069     } catch (Dali::DaliException e) {
73070       {
73071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73072       };
73073     } catch (...) {
73074       {
73075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73076       };
73077     }
73078   }
73079
73080 }
73081
73082
73083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73084   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73085   Dali::Actor arg2 ;
73086   Dali::Actor *argp2 ;
73087
73088   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73089   argp2 = (Dali::Actor *)jarg2;
73090   if (!argp2) {
73091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73092     return ;
73093   }
73094   arg2 = *argp2;
73095   {
73096     try {
73097       (arg1)->SetScrollIndicator(arg2);
73098     } catch (std::out_of_range& e) {
73099       {
73100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73101       };
73102     } catch (std::exception& e) {
73103       {
73104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73105       };
73106     } catch (Dali::DaliException e) {
73107       {
73108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73109       };
73110     } catch (...) {
73111       {
73112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73113       };
73114     }
73115   }
73116
73117 }
73118
73119
73120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73121   void * jresult ;
73122   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73123   Dali::Actor result;
73124
73125   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73126   {
73127     try {
73128       result = (arg1)->GetScrollIndicator();
73129     } catch (std::out_of_range& e) {
73130       {
73131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73132       };
73133     } catch (std::exception& e) {
73134       {
73135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73136       };
73137     } catch (Dali::DaliException e) {
73138       {
73139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73140       };
73141     } catch (...) {
73142       {
73143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73144       };
73145     }
73146   }
73147
73148   jresult = new Dali::Actor((const Dali::Actor &)result);
73149   return jresult;
73150 }
73151
73152
73153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73154   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73155   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73156
73157   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73158   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73159   if (!arg2) {
73160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73161     return ;
73162   }
73163   {
73164     try {
73165       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73166     } catch (std::out_of_range& e) {
73167       {
73168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73169       };
73170     } catch (std::exception& e) {
73171       {
73172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73173       };
73174     } catch (Dali::DaliException e) {
73175       {
73176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73177       };
73178     } catch (...) {
73179       {
73180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73181       };
73182     }
73183   }
73184
73185 }
73186
73187
73188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73189   void * jresult ;
73190   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73191
73192   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73193   {
73194     try {
73195       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()));
73196     } catch (std::out_of_range& e) {
73197       {
73198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73199       };
73200     } catch (std::exception& e) {
73201       {
73202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73203       };
73204     } catch (...) {
73205       {
73206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73207       };
73208     }
73209   }
73210   return jresult;
73211 }
73212
73213
73214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73215   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73216   Dali::Toolkit::ScrollBar::Direction arg2 ;
73217
73218   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73219   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73220   {
73221     try {
73222       (arg1)->SetScrollDirection(arg2);
73223     } catch (std::out_of_range& e) {
73224       {
73225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73226       };
73227     } catch (std::exception& e) {
73228       {
73229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73230       };
73231     } catch (Dali::DaliException e) {
73232       {
73233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73234       };
73235     } catch (...) {
73236       {
73237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73238       };
73239     }
73240   }
73241
73242 }
73243
73244
73245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73246   int jresult ;
73247   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73248   Dali::Toolkit::ScrollBar::Direction result;
73249
73250   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73251   {
73252     try {
73253       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73254     } catch (std::out_of_range& e) {
73255       {
73256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73257       };
73258     } catch (std::exception& e) {
73259       {
73260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73261       };
73262     } catch (Dali::DaliException e) {
73263       {
73264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73265       };
73266     } catch (...) {
73267       {
73268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73269       };
73270     }
73271   }
73272
73273   jresult = (int)result;
73274   return jresult;
73275 }
73276
73277
73278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73279   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73280   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73281
73282   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73283   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73284   {
73285     try {
73286       (arg1)->SetIndicatorHeightPolicy(arg2);
73287     } catch (std::out_of_range& e) {
73288       {
73289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73290       };
73291     } catch (std::exception& e) {
73292       {
73293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73294       };
73295     } catch (Dali::DaliException e) {
73296       {
73297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73298       };
73299     } catch (...) {
73300       {
73301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73302       };
73303     }
73304   }
73305
73306 }
73307
73308
73309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73310   int jresult ;
73311   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73312   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73313
73314   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73315   {
73316     try {
73317       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73318     } catch (std::out_of_range& e) {
73319       {
73320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73321       };
73322     } catch (std::exception& e) {
73323       {
73324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73325       };
73326     } catch (Dali::DaliException e) {
73327       {
73328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73329       };
73330     } catch (...) {
73331       {
73332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73333       };
73334     }
73335   }
73336
73337   jresult = (int)result;
73338   return jresult;
73339 }
73340
73341
73342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73343   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73344   float arg2 ;
73345
73346   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73347   arg2 = (float)jarg2;
73348   {
73349     try {
73350       (arg1)->SetIndicatorFixedHeight(arg2);
73351     } catch (std::out_of_range& e) {
73352       {
73353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73354       };
73355     } catch (std::exception& e) {
73356       {
73357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73358       };
73359     } catch (Dali::DaliException e) {
73360       {
73361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73362       };
73363     } catch (...) {
73364       {
73365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73366       };
73367     }
73368   }
73369
73370 }
73371
73372
73373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73374   float jresult ;
73375   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73376   float result;
73377
73378   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73379   {
73380     try {
73381       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73382     } catch (std::out_of_range& e) {
73383       {
73384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73385       };
73386     } catch (std::exception& e) {
73387       {
73388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73389       };
73390     } catch (Dali::DaliException e) {
73391       {
73392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73393       };
73394     } catch (...) {
73395       {
73396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73397       };
73398     }
73399   }
73400
73401   jresult = result;
73402   return jresult;
73403 }
73404
73405
73406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73407   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73408   float arg2 ;
73409
73410   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73411   arg2 = (float)jarg2;
73412   {
73413     try {
73414       (arg1)->SetIndicatorShowDuration(arg2);
73415     } catch (std::out_of_range& e) {
73416       {
73417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73418       };
73419     } catch (std::exception& e) {
73420       {
73421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73422       };
73423     } catch (Dali::DaliException e) {
73424       {
73425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73426       };
73427     } catch (...) {
73428       {
73429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73430       };
73431     }
73432   }
73433
73434 }
73435
73436
73437 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73438   float jresult ;
73439   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73440   float result;
73441
73442   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73443   {
73444     try {
73445       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73446     } catch (std::out_of_range& e) {
73447       {
73448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73449       };
73450     } catch (std::exception& e) {
73451       {
73452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73453       };
73454     } catch (Dali::DaliException e) {
73455       {
73456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73457       };
73458     } catch (...) {
73459       {
73460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73461       };
73462     }
73463   }
73464
73465   jresult = result;
73466   return jresult;
73467 }
73468
73469
73470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73471   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73472   float arg2 ;
73473
73474   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73475   arg2 = (float)jarg2;
73476   {
73477     try {
73478       (arg1)->SetIndicatorHideDuration(arg2);
73479     } catch (std::out_of_range& e) {
73480       {
73481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73482       };
73483     } catch (std::exception& e) {
73484       {
73485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73486       };
73487     } catch (Dali::DaliException e) {
73488       {
73489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73490       };
73491     } catch (...) {
73492       {
73493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73494       };
73495     }
73496   }
73497
73498 }
73499
73500
73501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73502   float jresult ;
73503   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73504   float result;
73505
73506   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73507   {
73508     try {
73509       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73510     } catch (std::out_of_range& e) {
73511       {
73512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73513       };
73514     } catch (std::exception& e) {
73515       {
73516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73517       };
73518     } catch (Dali::DaliException e) {
73519       {
73520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73521       };
73522     } catch (...) {
73523       {
73524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73525       };
73526     }
73527   }
73528
73529   jresult = result;
73530   return jresult;
73531 }
73532
73533
73534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73535   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73536
73537   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73538   {
73539     try {
73540       (arg1)->ShowIndicator();
73541     } catch (std::out_of_range& e) {
73542       {
73543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73544       };
73545     } catch (std::exception& e) {
73546       {
73547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73548       };
73549     } catch (Dali::DaliException e) {
73550       {
73551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73552       };
73553     } catch (...) {
73554       {
73555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73556       };
73557     }
73558   }
73559
73560 }
73561
73562
73563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73564   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73565
73566   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73567   {
73568     try {
73569       (arg1)->HideIndicator();
73570     } catch (std::out_of_range& e) {
73571       {
73572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73573       };
73574     } catch (std::exception& e) {
73575       {
73576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73577       };
73578     } catch (Dali::DaliException e) {
73579       {
73580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73581       };
73582     } catch (...) {
73583       {
73584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73585       };
73586     }
73587   }
73588
73589 }
73590
73591
73592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73593   void * jresult ;
73594   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73595   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73596
73597   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73598   {
73599     try {
73600       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73601     } catch (std::out_of_range& e) {
73602       {
73603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73604       };
73605     } catch (std::exception& e) {
73606       {
73607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73608       };
73609     } catch (Dali::DaliException e) {
73610       {
73611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73612       };
73613     } catch (...) {
73614       {
73615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73616       };
73617     }
73618   }
73619
73620   jresult = (void *)result;
73621   return jresult;
73622 }
73623
73624
73625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73626   void * jresult ;
73627   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73628   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73629
73630   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73631   {
73632     try {
73633       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73634     } catch (std::out_of_range& e) {
73635       {
73636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73637       };
73638     } catch (std::exception& e) {
73639       {
73640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73641       };
73642     } catch (Dali::DaliException e) {
73643       {
73644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73645       };
73646     } catch (...) {
73647       {
73648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73649       };
73650     }
73651   }
73652
73653   jresult = (void *)result;
73654   return jresult;
73655 }
73656
73657
73658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73659   int jresult ;
73660   int result;
73661
73662   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73663   jresult = (int)result;
73664   return jresult;
73665 }
73666
73667
73668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73669   int jresult ;
73670   int result;
73671
73672   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73673   jresult = (int)result;
73674   return jresult;
73675 }
73676
73677
73678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73679   int jresult ;
73680   int result;
73681
73682   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73683   jresult = (int)result;
73684   return jresult;
73685 }
73686
73687
73688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73689   int jresult ;
73690   int result;
73691
73692   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73693   jresult = (int)result;
73694   return jresult;
73695 }
73696
73697
73698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73699   int jresult ;
73700   int result;
73701
73702   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73703   jresult = (int)result;
73704   return jresult;
73705 }
73706
73707
73708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73709   int jresult ;
73710   int result;
73711
73712   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73713   jresult = (int)result;
73714   return jresult;
73715 }
73716
73717
73718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73719   int jresult ;
73720   int result;
73721
73722   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73723   jresult = (int)result;
73724   return jresult;
73725 }
73726
73727
73728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73729   int jresult ;
73730   int result;
73731
73732   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73733   jresult = (int)result;
73734   return jresult;
73735 }
73736
73737
73738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73739   int jresult ;
73740   int result;
73741
73742   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73743   jresult = (int)result;
73744   return jresult;
73745 }
73746
73747
73748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73749   int jresult ;
73750   int result;
73751
73752   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73753   jresult = (int)result;
73754   return jresult;
73755 }
73756
73757
73758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73759   int jresult ;
73760   int result;
73761
73762   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73763   jresult = (int)result;
73764   return jresult;
73765 }
73766
73767
73768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73769   int jresult ;
73770   int result;
73771
73772   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73773   jresult = (int)result;
73774   return jresult;
73775 }
73776
73777
73778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73779   int jresult ;
73780   int result;
73781
73782   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73783   jresult = (int)result;
73784   return jresult;
73785 }
73786
73787
73788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73789   int jresult ;
73790   int result;
73791
73792   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73793   jresult = (int)result;
73794   return jresult;
73795 }
73796
73797
73798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73799   void * jresult ;
73800   Dali::Toolkit::Scrollable::Property *result = 0 ;
73801
73802   {
73803     try {
73804       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73805     } catch (std::out_of_range& e) {
73806       {
73807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73808       };
73809     } catch (std::exception& e) {
73810       {
73811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73812       };
73813     } catch (Dali::DaliException e) {
73814       {
73815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73816       };
73817     } catch (...) {
73818       {
73819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73820       };
73821     }
73822   }
73823
73824   jresult = (void *)result;
73825   return jresult;
73826 }
73827
73828
73829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73830   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73831
73832   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73833   {
73834     try {
73835       delete arg1;
73836     } catch (std::out_of_range& e) {
73837       {
73838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73839       };
73840     } catch (std::exception& e) {
73841       {
73842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73843       };
73844     } catch (Dali::DaliException e) {
73845       {
73846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73847       };
73848     } catch (...) {
73849       {
73850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73851       };
73852     }
73853   }
73854
73855 }
73856
73857
73858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73859   void * jresult ;
73860   Dali::Toolkit::Scrollable *result = 0 ;
73861
73862   {
73863     try {
73864       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73865     } catch (std::out_of_range& e) {
73866       {
73867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73868       };
73869     } catch (std::exception& e) {
73870       {
73871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73872       };
73873     } catch (Dali::DaliException e) {
73874       {
73875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73876       };
73877     } catch (...) {
73878       {
73879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73880       };
73881     }
73882   }
73883
73884   jresult = (void *)result;
73885   return jresult;
73886 }
73887
73888
73889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73890   void * jresult ;
73891   Dali::Toolkit::Scrollable *arg1 = 0 ;
73892   Dali::Toolkit::Scrollable *result = 0 ;
73893
73894   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73895   if (!arg1) {
73896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73897     return 0;
73898   }
73899   {
73900     try {
73901       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73902     } catch (std::out_of_range& e) {
73903       {
73904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73905       };
73906     } catch (std::exception& e) {
73907       {
73908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73909       };
73910     } catch (Dali::DaliException e) {
73911       {
73912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73913       };
73914     } catch (...) {
73915       {
73916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73917       };
73918     }
73919   }
73920
73921   jresult = (void *)result;
73922   return jresult;
73923 }
73924
73925
73926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73927   void * jresult ;
73928   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73929   Dali::Toolkit::Scrollable *arg2 = 0 ;
73930   Dali::Toolkit::Scrollable *result = 0 ;
73931
73932   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73933   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73934   if (!arg2) {
73935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73936     return 0;
73937   }
73938   {
73939     try {
73940       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73941     } catch (std::out_of_range& e) {
73942       {
73943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73944       };
73945     } catch (std::exception& e) {
73946       {
73947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73948       };
73949     } catch (Dali::DaliException e) {
73950       {
73951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73952       };
73953     } catch (...) {
73954       {
73955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73956       };
73957     }
73958   }
73959
73960   jresult = (void *)result;
73961   return jresult;
73962 }
73963
73964
73965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73966   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73967
73968   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73969   {
73970     try {
73971       delete arg1;
73972     } catch (std::out_of_range& e) {
73973       {
73974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73975       };
73976     } catch (std::exception& e) {
73977       {
73978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73979       };
73980     } catch (Dali::DaliException e) {
73981       {
73982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73983       };
73984     } catch (...) {
73985       {
73986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73987       };
73988     }
73989   }
73990
73991 }
73992
73993
73994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73995   void * jresult ;
73996   Dali::BaseHandle arg1 ;
73997   Dali::BaseHandle *argp1 ;
73998   Dali::Toolkit::Scrollable result;
73999
74000   argp1 = (Dali::BaseHandle *)jarg1;
74001   if (!argp1) {
74002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74003     return 0;
74004   }
74005   arg1 = *argp1;
74006   {
74007     try {
74008       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74009     } catch (std::out_of_range& e) {
74010       {
74011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74012       };
74013     } catch (std::exception& e) {
74014       {
74015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74016       };
74017     } catch (Dali::DaliException e) {
74018       {
74019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74020       };
74021     } catch (...) {
74022       {
74023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74024       };
74025     }
74026   }
74027
74028   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74029   return jresult;
74030 }
74031
74032
74033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74034   unsigned int jresult ;
74035   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74036   bool result;
74037
74038   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74039   {
74040     try {
74041       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74042     } catch (std::out_of_range& e) {
74043       {
74044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74045       };
74046     } catch (std::exception& e) {
74047       {
74048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74049       };
74050     } catch (Dali::DaliException e) {
74051       {
74052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74053       };
74054     } catch (...) {
74055       {
74056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74057       };
74058     }
74059   }
74060
74061   jresult = result;
74062   return jresult;
74063 }
74064
74065
74066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74067   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74068   bool arg2 ;
74069
74070   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74071   arg2 = jarg2 ? true : false;
74072   {
74073     try {
74074       (arg1)->SetOvershootEnabled(arg2);
74075     } catch (std::out_of_range& e) {
74076       {
74077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74078       };
74079     } catch (std::exception& e) {
74080       {
74081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74082       };
74083     } catch (Dali::DaliException e) {
74084       {
74085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74086       };
74087     } catch (...) {
74088       {
74089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74090       };
74091     }
74092   }
74093
74094 }
74095
74096
74097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74098   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74099   Dali::Vector4 *arg2 = 0 ;
74100
74101   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74102   arg2 = (Dali::Vector4 *)jarg2;
74103   if (!arg2) {
74104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74105     return ;
74106   }
74107   {
74108     try {
74109       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74110     } catch (std::out_of_range& e) {
74111       {
74112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74113       };
74114     } catch (std::exception& e) {
74115       {
74116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74117       };
74118     } catch (Dali::DaliException e) {
74119       {
74120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74121       };
74122     } catch (...) {
74123       {
74124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74125       };
74126     }
74127   }
74128
74129 }
74130
74131
74132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74133   void * jresult ;
74134   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74135   Dali::Vector4 result;
74136
74137   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74138   {
74139     try {
74140       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74141     } catch (std::out_of_range& e) {
74142       {
74143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74144       };
74145     } catch (std::exception& e) {
74146       {
74147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74148       };
74149     } catch (Dali::DaliException e) {
74150       {
74151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74152       };
74153     } catch (...) {
74154       {
74155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74156       };
74157     }
74158   }
74159
74160   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74161   return jresult;
74162 }
74163
74164
74165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74166   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74167   float arg2 ;
74168
74169   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74170   arg2 = (float)jarg2;
74171   {
74172     try {
74173       (arg1)->SetOvershootAnimationSpeed(arg2);
74174     } catch (std::out_of_range& e) {
74175       {
74176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74177       };
74178     } catch (std::exception& e) {
74179       {
74180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74181       };
74182     } catch (Dali::DaliException e) {
74183       {
74184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74185       };
74186     } catch (...) {
74187       {
74188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74189       };
74190     }
74191   }
74192
74193 }
74194
74195
74196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74197   float jresult ;
74198   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74199   float result;
74200
74201   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74202   {
74203     try {
74204       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74205     } catch (std::out_of_range& e) {
74206       {
74207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74208       };
74209     } catch (std::exception& e) {
74210       {
74211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74212       };
74213     } catch (Dali::DaliException e) {
74214       {
74215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74216       };
74217     } catch (...) {
74218       {
74219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74220       };
74221     }
74222   }
74223
74224   jresult = result;
74225   return jresult;
74226 }
74227
74228
74229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74230   void * jresult ;
74231   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74232   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74233
74234   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74235   {
74236     try {
74237       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74238     } catch (std::out_of_range& e) {
74239       {
74240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74241       };
74242     } catch (std::exception& e) {
74243       {
74244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74245       };
74246     } catch (Dali::DaliException e) {
74247       {
74248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74249       };
74250     } catch (...) {
74251       {
74252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74253       };
74254     }
74255   }
74256
74257   jresult = (void *)result;
74258   return jresult;
74259 }
74260
74261
74262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74263   void * jresult ;
74264   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74265   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74266
74267   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74268   {
74269     try {
74270       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74271     } catch (std::out_of_range& e) {
74272       {
74273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74274       };
74275     } catch (std::exception& e) {
74276       {
74277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74278       };
74279     } catch (Dali::DaliException e) {
74280       {
74281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74282       };
74283     } catch (...) {
74284       {
74285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74286       };
74287     }
74288   }
74289
74290   jresult = (void *)result;
74291   return jresult;
74292 }
74293
74294
74295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74296   void * jresult ;
74297   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74298   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74299
74300   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74301   {
74302     try {
74303       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74304     } catch (std::out_of_range& e) {
74305       {
74306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74307       };
74308     } catch (std::exception& e) {
74309       {
74310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74311       };
74312     } catch (Dali::DaliException e) {
74313       {
74314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74315       };
74316     } catch (...) {
74317       {
74318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74319       };
74320     }
74321   }
74322
74323   jresult = (void *)result;
74324   return jresult;
74325 }
74326
74327
74328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74329   unsigned int jresult ;
74330   Dali::Toolkit::ControlOrientation::Type arg1 ;
74331   bool result;
74332
74333   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74334   {
74335     try {
74336       result = (bool)Dali::Toolkit::IsVertical(arg1);
74337     } catch (std::out_of_range& e) {
74338       {
74339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74340       };
74341     } catch (std::exception& e) {
74342       {
74343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74344       };
74345     } catch (Dali::DaliException e) {
74346       {
74347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74348       };
74349     } catch (...) {
74350       {
74351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74352       };
74353     }
74354   }
74355
74356   jresult = result;
74357   return jresult;
74358 }
74359
74360
74361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74362   unsigned int jresult ;
74363   Dali::Toolkit::ControlOrientation::Type arg1 ;
74364   bool result;
74365
74366   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74367   {
74368     try {
74369       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74370     } catch (std::out_of_range& e) {
74371       {
74372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74373       };
74374     } catch (std::exception& e) {
74375       {
74376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74377       };
74378     } catch (Dali::DaliException e) {
74379       {
74380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74381       };
74382     } catch (...) {
74383       {
74384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74385       };
74386     }
74387   }
74388
74389   jresult = result;
74390   return jresult;
74391 }
74392
74393
74394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74395   void * jresult ;
74396   unsigned int arg1 ;
74397   unsigned int arg2 ;
74398   Dali::Toolkit::ItemRange *result = 0 ;
74399
74400   arg1 = (unsigned int)jarg1;
74401   arg2 = (unsigned int)jarg2;
74402   {
74403     try {
74404       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74405     } catch (std::out_of_range& e) {
74406       {
74407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74408       };
74409     } catch (std::exception& e) {
74410       {
74411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74412       };
74413     } catch (Dali::DaliException e) {
74414       {
74415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74416       };
74417     } catch (...) {
74418       {
74419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74420       };
74421     }
74422   }
74423
74424   jresult = (void *)result;
74425   return jresult;
74426 }
74427
74428
74429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74430   void * jresult ;
74431   Dali::Toolkit::ItemRange *arg1 = 0 ;
74432   Dali::Toolkit::ItemRange *result = 0 ;
74433
74434   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74435   if (!arg1) {
74436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74437     return 0;
74438   }
74439   {
74440     try {
74441       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74442     } catch (std::out_of_range& e) {
74443       {
74444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74445       };
74446     } catch (std::exception& e) {
74447       {
74448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74449       };
74450     } catch (Dali::DaliException e) {
74451       {
74452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74453       };
74454     } catch (...) {
74455       {
74456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74457       };
74458     }
74459   }
74460
74461   jresult = (void *)result;
74462   return jresult;
74463 }
74464
74465
74466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74467   void * jresult ;
74468   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74469   Dali::Toolkit::ItemRange *arg2 = 0 ;
74470   Dali::Toolkit::ItemRange *result = 0 ;
74471
74472   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74473   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74474   if (!arg2) {
74475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74476     return 0;
74477   }
74478   {
74479     try {
74480       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74481     } catch (std::out_of_range& e) {
74482       {
74483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74484       };
74485     } catch (std::exception& e) {
74486       {
74487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74488       };
74489     } catch (Dali::DaliException e) {
74490       {
74491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74492       };
74493     } catch (...) {
74494       {
74495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74496       };
74497     }
74498   }
74499
74500   jresult = (void *)result;
74501   return jresult;
74502 }
74503
74504
74505 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74506   unsigned int jresult ;
74507   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74508   unsigned int arg2 ;
74509   bool result;
74510
74511   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74512   arg2 = (unsigned int)jarg2;
74513   {
74514     try {
74515       result = (bool)(arg1)->Within(arg2);
74516     } catch (std::out_of_range& e) {
74517       {
74518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74519       };
74520     } catch (std::exception& e) {
74521       {
74522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74523       };
74524     } catch (Dali::DaliException e) {
74525       {
74526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74527       };
74528     } catch (...) {
74529       {
74530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74531       };
74532     }
74533   }
74534
74535   jresult = result;
74536   return jresult;
74537 }
74538
74539
74540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74541   void * jresult ;
74542   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74543   Dali::Toolkit::ItemRange *arg2 = 0 ;
74544   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74545
74546   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74547   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74548   if (!arg2) {
74549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74550     return 0;
74551   }
74552   {
74553     try {
74554       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74555     } catch (std::out_of_range& e) {
74556       {
74557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74558       };
74559     } catch (std::exception& e) {
74560       {
74561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74562       };
74563     } catch (Dali::DaliException e) {
74564       {
74565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74566       };
74567     } catch (...) {
74568       {
74569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74570       };
74571     }
74572   }
74573
74574   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74575   return jresult;
74576 }
74577
74578
74579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74580   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74581   unsigned int arg2 ;
74582
74583   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74584   arg2 = (unsigned int)jarg2;
74585   if (arg1) (arg1)->begin = arg2;
74586 }
74587
74588
74589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74590   unsigned int jresult ;
74591   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74592   unsigned int result;
74593
74594   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74595   result = (unsigned int) ((arg1)->begin);
74596   jresult = result;
74597   return jresult;
74598 }
74599
74600
74601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74602   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74603   unsigned int arg2 ;
74604
74605   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74606   arg2 = (unsigned int)jarg2;
74607   if (arg1) (arg1)->end = arg2;
74608 }
74609
74610
74611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74612   unsigned int jresult ;
74613   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74614   unsigned int result;
74615
74616   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74617   result = (unsigned int) ((arg1)->end);
74618   jresult = result;
74619   return jresult;
74620 }
74621
74622
74623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74624   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74625
74626   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74627   {
74628     try {
74629       delete arg1;
74630     } catch (std::out_of_range& e) {
74631       {
74632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74633       };
74634     } catch (std::exception& e) {
74635       {
74636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74637       };
74638     } catch (Dali::DaliException e) {
74639       {
74640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74641       };
74642     } catch (...) {
74643       {
74644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74645       };
74646     }
74647   }
74648
74649 }
74650
74651
74652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74653   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74654
74655   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74656   {
74657     try {
74658       delete arg1;
74659     } catch (std::out_of_range& e) {
74660       {
74661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74662       };
74663     } catch (std::exception& e) {
74664       {
74665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74666       };
74667     } catch (Dali::DaliException e) {
74668       {
74669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74670       };
74671     } catch (...) {
74672       {
74673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74674       };
74675     }
74676   }
74677
74678 }
74679
74680
74681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74682   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74683   Dali::Toolkit::ControlOrientation::Type arg2 ;
74684
74685   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74686   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74687   {
74688     try {
74689       (arg1)->SetOrientation(arg2);
74690     } catch (std::out_of_range& e) {
74691       {
74692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74693       };
74694     } catch (std::exception& e) {
74695       {
74696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74697       };
74698     } catch (Dali::DaliException e) {
74699       {
74700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74701       };
74702     } catch (...) {
74703       {
74704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74705       };
74706     }
74707   }
74708
74709 }
74710
74711
74712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74713   int jresult ;
74714   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74715   Dali::Toolkit::ControlOrientation::Type result;
74716
74717   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74718   {
74719     try {
74720       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74721     } catch (std::out_of_range& e) {
74722       {
74723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74724       };
74725     } catch (std::exception& e) {
74726       {
74727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74728       };
74729     } catch (Dali::DaliException e) {
74730       {
74731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74732       };
74733     } catch (...) {
74734       {
74735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74736       };
74737     }
74738   }
74739
74740   jresult = (int)result;
74741   return jresult;
74742 }
74743
74744
74745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74746   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74747   Dali::Property::Map *arg2 = 0 ;
74748
74749   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74750   arg2 = (Dali::Property::Map *)jarg2;
74751   if (!arg2) {
74752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74753     return ;
74754   }
74755   {
74756     try {
74757       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74758     } catch (std::out_of_range& e) {
74759       {
74760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74761       };
74762     } catch (std::exception& e) {
74763       {
74764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74765       };
74766     } catch (Dali::DaliException e) {
74767       {
74768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74769       };
74770     } catch (...) {
74771       {
74772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74773       };
74774     }
74775   }
74776
74777 }
74778
74779
74780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74781   void * jresult ;
74782   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74783   Dali::Property::Map result;
74784
74785   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74786   {
74787     try {
74788       result = (arg1)->GetLayoutProperties();
74789     } catch (std::out_of_range& e) {
74790       {
74791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74792       };
74793     } catch (std::exception& e) {
74794       {
74795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74796       };
74797     } catch (Dali::DaliException e) {
74798       {
74799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74800       };
74801     } catch (...) {
74802       {
74803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74804       };
74805     }
74806   }
74807
74808   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74809   return jresult;
74810 }
74811
74812
74813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74814   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74815   unsigned int arg2 ;
74816   Dali::Vector3 *arg3 = 0 ;
74817   Dali::Vector3 *arg4 = 0 ;
74818
74819   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74820   arg2 = (unsigned int)jarg2;
74821   arg3 = (Dali::Vector3 *)jarg3;
74822   if (!arg3) {
74823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74824     return ;
74825   }
74826   arg4 = (Dali::Vector3 *)jarg4;
74827   if (!arg4) {
74828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74829     return ;
74830   }
74831   {
74832     try {
74833       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74834     } catch (std::out_of_range& e) {
74835       {
74836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74837       };
74838     } catch (std::exception& e) {
74839       {
74840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74841       };
74842     } catch (Dali::DaliException e) {
74843       {
74844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74845       };
74846     } catch (...) {
74847       {
74848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74849       };
74850     }
74851   }
74852
74853 }
74854
74855
74856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74857   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74858   Dali::Vector3 *arg2 = 0 ;
74859
74860   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74861   arg2 = (Dali::Vector3 *)jarg2;
74862   if (!arg2) {
74863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74864     return ;
74865   }
74866   {
74867     try {
74868       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74869     } catch (std::out_of_range& e) {
74870       {
74871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74872       };
74873     } catch (std::exception& e) {
74874       {
74875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74876       };
74877     } catch (Dali::DaliException e) {
74878       {
74879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74880       };
74881     } catch (...) {
74882       {
74883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74884       };
74885     }
74886   }
74887
74888 }
74889
74890
74891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74892   float jresult ;
74893   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74894   unsigned int arg2 ;
74895   Dali::Vector3 arg3 ;
74896   Dali::Vector3 *argp3 ;
74897   float result;
74898
74899   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74900   arg2 = (unsigned int)jarg2;
74901   argp3 = (Dali::Vector3 *)jarg3;
74902   if (!argp3) {
74903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74904     return 0;
74905   }
74906   arg3 = *argp3;
74907   {
74908     try {
74909       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74910     } catch (std::out_of_range& e) {
74911       {
74912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74913       };
74914     } catch (std::exception& e) {
74915       {
74916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74917       };
74918     } catch (Dali::DaliException e) {
74919       {
74920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74921       };
74922     } catch (...) {
74923       {
74924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74925       };
74926     }
74927   }
74928
74929   jresult = result;
74930   return jresult;
74931 }
74932
74933
74934 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74935   float jresult ;
74936   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74937   float arg2 ;
74938   float result;
74939
74940   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74941   arg2 = (float)jarg2;
74942   {
74943     try {
74944       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74945     } catch (std::out_of_range& e) {
74946       {
74947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74948       };
74949     } catch (std::exception& e) {
74950       {
74951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74952       };
74953     } catch (Dali::DaliException e) {
74954       {
74955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74956       };
74957     } catch (...) {
74958       {
74959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74960       };
74961     }
74962   }
74963
74964   jresult = result;
74965   return jresult;
74966 }
74967
74968
74969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74970   float jresult ;
74971   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74972   unsigned int arg2 ;
74973   float result;
74974
74975   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74976   arg2 = (unsigned int)jarg2;
74977   {
74978     try {
74979       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74980     } catch (std::out_of_range& e) {
74981       {
74982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74983       };
74984     } catch (std::exception& e) {
74985       {
74986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74987       };
74988     } catch (Dali::DaliException e) {
74989       {
74990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74991       };
74992     } catch (...) {
74993       {
74994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74995       };
74996     }
74997   }
74998
74999   jresult = result;
75000   return jresult;
75001 }
75002
75003
75004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75005   void * jresult ;
75006   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75007   float arg2 ;
75008   Dali::Vector3 arg3 ;
75009   Dali::Vector3 *argp3 ;
75010   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75011
75012   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75013   arg2 = (float)jarg2;
75014   argp3 = (Dali::Vector3 *)jarg3;
75015   if (!argp3) {
75016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75017     return 0;
75018   }
75019   arg3 = *argp3;
75020   {
75021     try {
75022       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75023     } catch (std::out_of_range& e) {
75024       {
75025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75026       };
75027     } catch (std::exception& e) {
75028       {
75029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75030       };
75031     } catch (Dali::DaliException e) {
75032       {
75033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75034       };
75035     } catch (...) {
75036       {
75037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75038       };
75039     }
75040   }
75041
75042   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75043   return jresult;
75044 }
75045
75046
75047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75048   float jresult ;
75049   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75050   int arg2 ;
75051   float arg3 ;
75052   Dali::Vector3 *arg4 = 0 ;
75053   float result;
75054
75055   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75056   arg2 = (int)jarg2;
75057   arg3 = (float)jarg3;
75058   arg4 = (Dali::Vector3 *)jarg4;
75059   if (!arg4) {
75060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75061     return 0;
75062   }
75063   {
75064     try {
75065       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75066     } catch (std::out_of_range& e) {
75067       {
75068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75069       };
75070     } catch (std::exception& e) {
75071       {
75072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75073       };
75074     } catch (Dali::DaliException e) {
75075       {
75076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75077       };
75078     } catch (...) {
75079       {
75080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75081       };
75082     }
75083   }
75084
75085   jresult = result;
75086   return jresult;
75087 }
75088
75089
75090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75091   unsigned int jresult ;
75092   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75093   Dali::Vector3 arg2 ;
75094   Dali::Vector3 *argp2 ;
75095   unsigned int result;
75096
75097   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75098   argp2 = (Dali::Vector3 *)jarg2;
75099   if (!argp2) {
75100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75101     return 0;
75102   }
75103   arg2 = *argp2;
75104   {
75105     try {
75106       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75107     } catch (std::out_of_range& e) {
75108       {
75109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75110       };
75111     } catch (std::exception& e) {
75112       {
75113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75114       };
75115     } catch (Dali::DaliException e) {
75116       {
75117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75118       };
75119     } catch (...) {
75120       {
75121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75122       };
75123     }
75124   }
75125
75126   jresult = result;
75127   return jresult;
75128 }
75129
75130
75131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75132   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75133   unsigned int arg2 ;
75134   Dali::Vector3 *arg3 = 0 ;
75135   Dali::Vector3 *arg4 = 0 ;
75136
75137   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75138   arg2 = (unsigned int)jarg2;
75139   arg3 = (Dali::Vector3 *)jarg3;
75140   if (!arg3) {
75141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75142     return ;
75143   }
75144   arg4 = (Dali::Vector3 *)jarg4;
75145   if (!arg4) {
75146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75147     return ;
75148   }
75149   {
75150     try {
75151       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75152     } catch (std::out_of_range& e) {
75153       {
75154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75155       };
75156     } catch (std::exception& e) {
75157       {
75158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75159       };
75160     } catch (Dali::DaliException e) {
75161       {
75162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75163       };
75164     } catch (...) {
75165       {
75166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75167       };
75168     }
75169   }
75170
75171 }
75172
75173
75174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75175   void * jresult ;
75176   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75177   Dali::Degree result;
75178
75179   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75180   {
75181     try {
75182       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75183     } catch (std::out_of_range& e) {
75184       {
75185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75186       };
75187     } catch (std::exception& e) {
75188       {
75189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75190       };
75191     } catch (Dali::DaliException e) {
75192       {
75193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75194       };
75195     } catch (...) {
75196       {
75197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75198       };
75199     }
75200   }
75201
75202   jresult = new Dali::Degree((const Dali::Degree &)result);
75203   return jresult;
75204 }
75205
75206
75207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75208   float jresult ;
75209   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75210   float result;
75211
75212   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75213   {
75214     try {
75215       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75216     } catch (std::out_of_range& e) {
75217       {
75218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75219       };
75220     } catch (std::exception& e) {
75221       {
75222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75223       };
75224     } catch (Dali::DaliException e) {
75225       {
75226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75227       };
75228     } catch (...) {
75229       {
75230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75231       };
75232     }
75233   }
75234
75235   jresult = result;
75236   return jresult;
75237 }
75238
75239
75240 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75241   float jresult ;
75242   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75243   float result;
75244
75245   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75246   {
75247     try {
75248       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75249     } catch (std::out_of_range& e) {
75250       {
75251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75252       };
75253     } catch (std::exception& e) {
75254       {
75255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75256       };
75257     } catch (Dali::DaliException e) {
75258       {
75259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75260       };
75261     } catch (...) {
75262       {
75263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75264       };
75265     }
75266   }
75267
75268   jresult = result;
75269   return jresult;
75270 }
75271
75272
75273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75274   float jresult ;
75275   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75276   float result;
75277
75278   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75279   {
75280     try {
75281       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75282     } catch (std::out_of_range& e) {
75283       {
75284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75285       };
75286     } catch (std::exception& e) {
75287       {
75288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75289       };
75290     } catch (Dali::DaliException e) {
75291       {
75292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75293       };
75294     } catch (...) {
75295       {
75296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75297       };
75298     }
75299   }
75300
75301   jresult = result;
75302   return jresult;
75303 }
75304
75305
75306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75307   int jresult ;
75308   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75309   int arg2 ;
75310   int arg3 ;
75311   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75312   bool arg5 ;
75313   int result;
75314
75315   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75316   arg2 = (int)jarg2;
75317   arg3 = (int)jarg3;
75318   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75319   arg5 = jarg5 ? true : false;
75320   {
75321     try {
75322       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75323     } catch (std::out_of_range& e) {
75324       {
75325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75326       };
75327     } catch (std::exception& e) {
75328       {
75329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75330       };
75331     } catch (Dali::DaliException e) {
75332       {
75333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75334       };
75335     } catch (...) {
75336       {
75337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75338       };
75339     }
75340   }
75341
75342   jresult = result;
75343   return jresult;
75344 }
75345
75346
75347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75348   float jresult ;
75349   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75350   float result;
75351
75352   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75353   {
75354     try {
75355       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
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 = result;
75376   return jresult;
75377 }
75378
75379
75380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75381   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75382   Dali::Actor *arg2 = 0 ;
75383   int arg3 ;
75384   Dali::Vector3 *arg4 = 0 ;
75385   Dali::Actor *arg5 = 0 ;
75386
75387   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75388   arg2 = (Dali::Actor *)jarg2;
75389   if (!arg2) {
75390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75391     return ;
75392   }
75393   arg3 = (int)jarg3;
75394   arg4 = (Dali::Vector3 *)jarg4;
75395   if (!arg4) {
75396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75397     return ;
75398   }
75399   arg5 = (Dali::Actor *)jarg5;
75400   if (!arg5) {
75401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75402     return ;
75403   }
75404   {
75405     try {
75406       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75407     } catch (std::out_of_range& e) {
75408       {
75409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75410       };
75411     } catch (std::exception& e) {
75412       {
75413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75414       };
75415     } catch (Dali::DaliException e) {
75416       {
75417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75418       };
75419     } catch (...) {
75420       {
75421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75422       };
75423     }
75424   }
75425
75426 }
75427
75428
75429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75430   void * jresult ;
75431   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75432   int arg2 ;
75433   float arg3 ;
75434   Dali::Vector3 *arg4 = 0 ;
75435   Dali::Vector3 result;
75436
75437   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75438   arg2 = (int)jarg2;
75439   arg3 = (float)jarg3;
75440   arg4 = (Dali::Vector3 *)jarg4;
75441   if (!arg4) {
75442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75443     return 0;
75444   }
75445   {
75446     try {
75447       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75448     } catch (std::out_of_range& e) {
75449       {
75450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75451       };
75452     } catch (std::exception& e) {
75453       {
75454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75455       };
75456     } catch (Dali::DaliException e) {
75457       {
75458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75459       };
75460     } catch (...) {
75461       {
75462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75463       };
75464     }
75465   }
75466
75467   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75468   return jresult;
75469 }
75470
75471
75472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75473   void * jresult ;
75474   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75475   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75476
75477   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75478   {
75479     try {
75480       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75481     } catch (std::out_of_range& e) {
75482       {
75483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75484       };
75485     } catch (std::exception& e) {
75486       {
75487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75488       };
75489     } catch (Dali::DaliException e) {
75490       {
75491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75492       };
75493     } catch (...) {
75494       {
75495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75496       };
75497     }
75498   }
75499
75500   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75501   return jresult;
75502 }
75503
75504
75505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75506   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75507
75508   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75509   {
75510     try {
75511       delete arg1;
75512     } catch (std::out_of_range& e) {
75513       {
75514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75515       };
75516     } catch (std::exception& e) {
75517       {
75518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75519       };
75520     } catch (Dali::DaliException e) {
75521       {
75522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75523       };
75524     } catch (...) {
75525       {
75526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75527       };
75528     }
75529   }
75530
75531 }
75532
75533
75534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75535   unsigned int jresult ;
75536   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75537   unsigned int result;
75538
75539   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75540   {
75541     try {
75542       result = (unsigned int)(arg1)->GetNumberOfItems();
75543     } catch (std::out_of_range& e) {
75544       {
75545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75546       };
75547     } catch (std::exception& e) {
75548       {
75549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75550       };
75551     } catch (Dali::DaliException e) {
75552       {
75553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75554       };
75555     } catch (...) {
75556       {
75557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75558       };
75559     }
75560   }
75561
75562   jresult = result;
75563   return jresult;
75564 }
75565
75566
75567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75568   void * jresult ;
75569   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75570   unsigned int arg2 ;
75571   Dali::Actor result;
75572
75573   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75574   arg2 = (unsigned int)jarg2;
75575   {
75576     try {
75577       result = (arg1)->NewItem(arg2);
75578     } catch (std::out_of_range& e) {
75579       {
75580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75581       };
75582     } catch (std::exception& e) {
75583       {
75584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75585       };
75586     } catch (Dali::DaliException e) {
75587       {
75588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75589       };
75590     } catch (...) {
75591       {
75592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75593       };
75594     }
75595   }
75596
75597   jresult = new Dali::Actor((const Dali::Actor &)result);
75598   return jresult;
75599 }
75600
75601
75602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75603   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75604   unsigned int arg2 ;
75605   Dali::Actor arg3 ;
75606   Dali::Actor *argp3 ;
75607
75608   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75609   arg2 = (unsigned int)jarg2;
75610   argp3 = (Dali::Actor *)jarg3;
75611   if (!argp3) {
75612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75613     return ;
75614   }
75615   arg3 = *argp3;
75616   {
75617     try {
75618       (arg1)->ItemReleased(arg2,arg3);
75619     } catch (std::out_of_range& e) {
75620       {
75621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75622       };
75623     } catch (std::exception& e) {
75624       {
75625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75626       };
75627     } catch (Dali::DaliException e) {
75628       {
75629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75630       };
75631     } catch (...) {
75632       {
75633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75634       };
75635     }
75636   }
75637
75638 }
75639
75640
75641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75642   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75643   unsigned int arg2 ;
75644   Dali::Actor arg3 ;
75645   Dali::Actor *argp3 ;
75646
75647   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75648   arg2 = (unsigned int)jarg2;
75649   argp3 = (Dali::Actor *)jarg3;
75650   if (!argp3) {
75651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75652     return ;
75653   }
75654   arg3 = *argp3;
75655   {
75656     try {
75657       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75658     } catch (std::out_of_range& e) {
75659       {
75660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75661       };
75662     } catch (std::exception& e) {
75663       {
75664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75665       };
75666     } catch (Dali::DaliException e) {
75667       {
75668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75669       };
75670     } catch (...) {
75671       {
75672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75673       };
75674     }
75675   }
75676
75677 }
75678
75679
75680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75681   void * jresult ;
75682   Dali::Toolkit::ItemFactory *result = 0 ;
75683
75684   {
75685     try {
75686       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75687     } catch (std::out_of_range& e) {
75688       {
75689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75690       };
75691     } catch (std::exception& e) {
75692       {
75693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75694       };
75695     } catch (Dali::DaliException e) {
75696       {
75697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75698       };
75699     } catch (...) {
75700       {
75701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75702       };
75703     }
75704   }
75705
75706   jresult = (void *)result;
75707   return jresult;
75708 }
75709
75710
75711 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) {
75712   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75713   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75714   if (director) {
75715     director->swig_connect_director(callback0, callback1, callback2);
75716   }
75717 }
75718
75719
75720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75721   int jresult ;
75722   int result;
75723
75724   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75725   jresult = (int)result;
75726   return jresult;
75727 }
75728
75729
75730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75731   int jresult ;
75732   int result;
75733
75734   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75735   jresult = (int)result;
75736   return jresult;
75737 }
75738
75739
75740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75741   int jresult ;
75742   int result;
75743
75744   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75745   jresult = (int)result;
75746   return jresult;
75747 }
75748
75749
75750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75751   int jresult ;
75752   int result;
75753
75754   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75755   jresult = (int)result;
75756   return jresult;
75757 }
75758
75759
75760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75761   int jresult ;
75762   int result;
75763
75764   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75765   jresult = (int)result;
75766   return jresult;
75767 }
75768
75769
75770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75771   int jresult ;
75772   int result;
75773
75774   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75775   jresult = (int)result;
75776   return jresult;
75777 }
75778
75779
75780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75781   int jresult ;
75782   int result;
75783
75784   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75785   jresult = (int)result;
75786   return jresult;
75787 }
75788
75789
75790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75791   int jresult ;
75792   int result;
75793
75794   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75795   jresult = (int)result;
75796   return jresult;
75797 }
75798
75799
75800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75801   int jresult ;
75802   int result;
75803
75804   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75805   jresult = (int)result;
75806   return jresult;
75807 }
75808
75809
75810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75811   int jresult ;
75812   int result;
75813
75814   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75815   jresult = (int)result;
75816   return jresult;
75817 }
75818
75819
75820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75821   int jresult ;
75822   int result;
75823
75824   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75825   jresult = (int)result;
75826   return jresult;
75827 }
75828
75829
75830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75831   void * jresult ;
75832   Dali::Toolkit::ItemView::Property *result = 0 ;
75833
75834   {
75835     try {
75836       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75837     } catch (std::out_of_range& e) {
75838       {
75839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75840       };
75841     } catch (std::exception& e) {
75842       {
75843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75844       };
75845     } catch (Dali::DaliException e) {
75846       {
75847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75848       };
75849     } catch (...) {
75850       {
75851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75852       };
75853     }
75854   }
75855
75856   jresult = (void *)result;
75857   return jresult;
75858 }
75859
75860
75861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75862   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75863
75864   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75865   {
75866     try {
75867       delete arg1;
75868     } catch (std::out_of_range& e) {
75869       {
75870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75871       };
75872     } catch (std::exception& e) {
75873       {
75874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75875       };
75876     } catch (Dali::DaliException e) {
75877       {
75878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75879       };
75880     } catch (...) {
75881       {
75882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75883       };
75884     }
75885   }
75886
75887 }
75888
75889
75890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75891   void * jresult ;
75892   Dali::Toolkit::ItemView *result = 0 ;
75893
75894   {
75895     try {
75896       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75897     } catch (std::out_of_range& e) {
75898       {
75899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75900       };
75901     } catch (std::exception& e) {
75902       {
75903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75904       };
75905     } catch (Dali::DaliException e) {
75906       {
75907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75908       };
75909     } catch (...) {
75910       {
75911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75912       };
75913     }
75914   }
75915
75916   jresult = (void *)result;
75917   return jresult;
75918 }
75919
75920
75921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75922   void * jresult ;
75923   Dali::Toolkit::ItemView *arg1 = 0 ;
75924   Dali::Toolkit::ItemView *result = 0 ;
75925
75926   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75927   if (!arg1) {
75928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75929     return 0;
75930   }
75931   {
75932     try {
75933       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75934     } catch (std::out_of_range& e) {
75935       {
75936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75937       };
75938     } catch (std::exception& e) {
75939       {
75940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75941       };
75942     } catch (Dali::DaliException e) {
75943       {
75944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75945       };
75946     } catch (...) {
75947       {
75948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75949       };
75950     }
75951   }
75952
75953   jresult = (void *)result;
75954   return jresult;
75955 }
75956
75957
75958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75959   void * jresult ;
75960   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75961   Dali::Toolkit::ItemView *arg2 = 0 ;
75962   Dali::Toolkit::ItemView *result = 0 ;
75963
75964   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75965   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75966   if (!arg2) {
75967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75968     return 0;
75969   }
75970   {
75971     try {
75972       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75973     } catch (std::out_of_range& e) {
75974       {
75975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75976       };
75977     } catch (std::exception& e) {
75978       {
75979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75980       };
75981     } catch (Dali::DaliException e) {
75982       {
75983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75984       };
75985     } catch (...) {
75986       {
75987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75988       };
75989     }
75990   }
75991
75992   jresult = (void *)result;
75993   return jresult;
75994 }
75995
75996
75997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75998   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75999
76000   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76001   {
76002     try {
76003       delete arg1;
76004     } catch (std::out_of_range& e) {
76005       {
76006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76007       };
76008     } catch (std::exception& e) {
76009       {
76010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76011       };
76012     } catch (Dali::DaliException e) {
76013       {
76014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76015       };
76016     } catch (...) {
76017       {
76018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76019       };
76020     }
76021   }
76022
76023 }
76024
76025
76026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76027   void * jresult ;
76028   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76029   Dali::Toolkit::ItemView result;
76030
76031   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76032   if (!arg1) {
76033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76034     return 0;
76035   }
76036   {
76037     try {
76038       result = Dali::Toolkit::ItemView::New(*arg1);
76039     } catch (std::out_of_range& e) {
76040       {
76041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76042       };
76043     } catch (std::exception& e) {
76044       {
76045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76046       };
76047     } catch (Dali::DaliException e) {
76048       {
76049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76050       };
76051     } catch (...) {
76052       {
76053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76054       };
76055     }
76056   }
76057
76058   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76059   return jresult;
76060 }
76061
76062
76063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76064   void * jresult ;
76065   Dali::BaseHandle arg1 ;
76066   Dali::BaseHandle *argp1 ;
76067   Dali::Toolkit::ItemView result;
76068
76069   argp1 = (Dali::BaseHandle *)jarg1;
76070   if (!argp1) {
76071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76072     return 0;
76073   }
76074   arg1 = *argp1;
76075   {
76076     try {
76077       result = Dali::Toolkit::ItemView::DownCast(arg1);
76078     } catch (std::out_of_range& e) {
76079       {
76080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76081       };
76082     } catch (std::exception& e) {
76083       {
76084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76085       };
76086     } catch (Dali::DaliException e) {
76087       {
76088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76089       };
76090     } catch (...) {
76091       {
76092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76093       };
76094     }
76095   }
76096
76097   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76098   return jresult;
76099 }
76100
76101
76102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76103   unsigned int jresult ;
76104   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76105   unsigned int result;
76106
76107   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76108   {
76109     try {
76110       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76111     } catch (std::out_of_range& e) {
76112       {
76113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76114       };
76115     } catch (std::exception& e) {
76116       {
76117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76118       };
76119     } catch (Dali::DaliException e) {
76120       {
76121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76122       };
76123     } catch (...) {
76124       {
76125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76126       };
76127     }
76128   }
76129
76130   jresult = result;
76131   return jresult;
76132 }
76133
76134
76135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76136   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76137   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76138
76139   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76140   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76141   if (!arg2) {
76142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76143     return ;
76144   }
76145   {
76146     try {
76147       (arg1)->AddLayout(*arg2);
76148     } catch (std::out_of_range& e) {
76149       {
76150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76151       };
76152     } catch (std::exception& e) {
76153       {
76154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76155       };
76156     } catch (Dali::DaliException e) {
76157       {
76158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76159       };
76160     } catch (...) {
76161       {
76162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76163       };
76164     }
76165   }
76166
76167 }
76168
76169
76170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76171   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76172   unsigned int arg2 ;
76173
76174   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76175   arg2 = (unsigned int)jarg2;
76176   {
76177     try {
76178       (arg1)->RemoveLayout(arg2);
76179     } catch (std::out_of_range& e) {
76180       {
76181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76182       };
76183     } catch (std::exception& e) {
76184       {
76185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76186       };
76187     } catch (Dali::DaliException e) {
76188       {
76189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76190       };
76191     } catch (...) {
76192       {
76193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76194       };
76195     }
76196   }
76197
76198 }
76199
76200
76201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76202   void * jresult ;
76203   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76204   unsigned int arg2 ;
76205   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76206
76207   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76208   arg2 = (unsigned int)jarg2;
76209   {
76210     try {
76211       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76212     } catch (std::out_of_range& e) {
76213       {
76214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76215       };
76216     } catch (std::exception& e) {
76217       {
76218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76219       };
76220     } catch (Dali::DaliException e) {
76221       {
76222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76223       };
76224     } catch (...) {
76225       {
76226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76227       };
76228     }
76229   }
76230
76231   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76232   return jresult;
76233 }
76234
76235
76236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76237   void * jresult ;
76238   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76239   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76240
76241   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76242   {
76243     try {
76244       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76245     } catch (std::out_of_range& e) {
76246       {
76247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76248       };
76249     } catch (std::exception& e) {
76250       {
76251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76252       };
76253     } catch (Dali::DaliException e) {
76254       {
76255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76256       };
76257     } catch (...) {
76258       {
76259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76260       };
76261     }
76262   }
76263
76264   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76265   return jresult;
76266 }
76267
76268
76269 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76270   float jresult ;
76271   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76272   Dali::Toolkit::ItemId arg2 ;
76273   float result;
76274
76275   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76276   arg2 = (Dali::Toolkit::ItemId)jarg2;
76277   {
76278     try {
76279       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76280     } catch (std::out_of_range& e) {
76281       {
76282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76283       };
76284     } catch (std::exception& e) {
76285       {
76286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76287       };
76288     } catch (Dali::DaliException e) {
76289       {
76290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76291       };
76292     } catch (...) {
76293       {
76294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76295       };
76296     }
76297   }
76298
76299   jresult = result;
76300   return jresult;
76301 }
76302
76303
76304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76305   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76306   unsigned int arg2 ;
76307   Dali::Vector3 arg3 ;
76308   float arg4 ;
76309   Dali::Vector3 *argp3 ;
76310
76311   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76312   arg2 = (unsigned int)jarg2;
76313   argp3 = (Dali::Vector3 *)jarg3;
76314   if (!argp3) {
76315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76316     return ;
76317   }
76318   arg3 = *argp3;
76319   arg4 = (float)jarg4;
76320   {
76321     try {
76322       (arg1)->ActivateLayout(arg2,arg3,arg4);
76323     } catch (std::out_of_range& e) {
76324       {
76325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76326       };
76327     } catch (std::exception& e) {
76328       {
76329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76330       };
76331     } catch (Dali::DaliException e) {
76332       {
76333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76334       };
76335     } catch (...) {
76336       {
76337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76338       };
76339     }
76340   }
76341
76342 }
76343
76344
76345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76346   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76347
76348   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76349   {
76350     try {
76351       (arg1)->DeactivateCurrentLayout();
76352     } catch (std::out_of_range& e) {
76353       {
76354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76355       };
76356     } catch (std::exception& e) {
76357       {
76358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76359       };
76360     } catch (Dali::DaliException e) {
76361       {
76362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76363       };
76364     } catch (...) {
76365       {
76366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76367       };
76368     }
76369   }
76370
76371 }
76372
76373
76374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76375   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76376   float arg2 ;
76377
76378   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76379   arg2 = (float)jarg2;
76380   {
76381     try {
76382       (arg1)->SetMinimumSwipeSpeed(arg2);
76383     } catch (std::out_of_range& e) {
76384       {
76385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76386       };
76387     } catch (std::exception& e) {
76388       {
76389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76390       };
76391     } catch (Dali::DaliException e) {
76392       {
76393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76394       };
76395     } catch (...) {
76396       {
76397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76398       };
76399     }
76400   }
76401
76402 }
76403
76404
76405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76406   float jresult ;
76407   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76408   float result;
76409
76410   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76411   {
76412     try {
76413       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76414     } catch (std::out_of_range& e) {
76415       {
76416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76417       };
76418     } catch (std::exception& e) {
76419       {
76420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76421       };
76422     } catch (Dali::DaliException e) {
76423       {
76424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76425       };
76426     } catch (...) {
76427       {
76428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76429       };
76430     }
76431   }
76432
76433   jresult = result;
76434   return jresult;
76435 }
76436
76437
76438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76439   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76440   float arg2 ;
76441
76442   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76443   arg2 = (float)jarg2;
76444   {
76445     try {
76446       (arg1)->SetMinimumSwipeDistance(arg2);
76447     } catch (std::out_of_range& e) {
76448       {
76449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76450       };
76451     } catch (std::exception& e) {
76452       {
76453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76454       };
76455     } catch (Dali::DaliException e) {
76456       {
76457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76458       };
76459     } catch (...) {
76460       {
76461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76462       };
76463     }
76464   }
76465
76466 }
76467
76468
76469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76470   float jresult ;
76471   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76472   float result;
76473
76474   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76475   {
76476     try {
76477       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76478     } catch (std::out_of_range& e) {
76479       {
76480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76481       };
76482     } catch (std::exception& e) {
76483       {
76484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76485       };
76486     } catch (Dali::DaliException e) {
76487       {
76488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76489       };
76490     } catch (...) {
76491       {
76492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76493       };
76494     }
76495   }
76496
76497   jresult = result;
76498   return jresult;
76499 }
76500
76501
76502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76503   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76504   float arg2 ;
76505
76506   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76507   arg2 = (float)jarg2;
76508   {
76509     try {
76510       (arg1)->SetWheelScrollDistanceStep(arg2);
76511     } catch (std::out_of_range& e) {
76512       {
76513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76514       };
76515     } catch (std::exception& e) {
76516       {
76517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76518       };
76519     } catch (Dali::DaliException e) {
76520       {
76521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76522       };
76523     } catch (...) {
76524       {
76525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76526       };
76527     }
76528   }
76529
76530 }
76531
76532
76533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76534   float jresult ;
76535   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76536   float result;
76537
76538   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76539   {
76540     try {
76541       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76542     } catch (std::out_of_range& e) {
76543       {
76544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76545       };
76546     } catch (std::exception& e) {
76547       {
76548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76549       };
76550     } catch (Dali::DaliException e) {
76551       {
76552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76553       };
76554     } catch (...) {
76555       {
76556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76557       };
76558     }
76559   }
76560
76561   jresult = result;
76562   return jresult;
76563 }
76564
76565
76566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76567   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76568   bool arg2 ;
76569
76570   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76571   arg2 = jarg2 ? true : false;
76572   {
76573     try {
76574       (arg1)->SetAnchoring(arg2);
76575     } catch (std::out_of_range& e) {
76576       {
76577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76578       };
76579     } catch (std::exception& e) {
76580       {
76581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76582       };
76583     } catch (Dali::DaliException e) {
76584       {
76585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76586       };
76587     } catch (...) {
76588       {
76589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76590       };
76591     }
76592   }
76593
76594 }
76595
76596 //// ========================= end of part 3 =============================
76597
76598 //// ========================== start part 4 ===============================
76599
76600
76601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76602   unsigned int jresult ;
76603   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76604   bool result;
76605
76606   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76607   {
76608     try {
76609       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76610     } catch (std::out_of_range& e) {
76611       {
76612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76613       };
76614     } catch (std::exception& e) {
76615       {
76616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76617       };
76618     } catch (Dali::DaliException e) {
76619       {
76620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76621       };
76622     } catch (...) {
76623       {
76624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76625       };
76626     }
76627   }
76628
76629   jresult = result;
76630   return jresult;
76631 }
76632
76633
76634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76635   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76636   float arg2 ;
76637
76638   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76639   arg2 = (float)jarg2;
76640   {
76641     try {
76642       (arg1)->SetAnchoringDuration(arg2);
76643     } catch (std::out_of_range& e) {
76644       {
76645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76646       };
76647     } catch (std::exception& e) {
76648       {
76649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76650       };
76651     } catch (Dali::DaliException e) {
76652       {
76653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76654       };
76655     } catch (...) {
76656       {
76657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76658       };
76659     }
76660   }
76661
76662 }
76663
76664
76665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76666   float jresult ;
76667   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76668   float result;
76669
76670   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76671   {
76672     try {
76673       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76674     } catch (std::out_of_range& e) {
76675       {
76676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76677       };
76678     } catch (std::exception& e) {
76679       {
76680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76681       };
76682     } catch (Dali::DaliException e) {
76683       {
76684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76685       };
76686     } catch (...) {
76687       {
76688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76689       };
76690     }
76691   }
76692
76693   jresult = result;
76694   return jresult;
76695 }
76696
76697
76698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76699   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76700   Dali::Toolkit::ItemId arg2 ;
76701   float arg3 ;
76702
76703   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76704   arg2 = (Dali::Toolkit::ItemId)jarg2;
76705   arg3 = (float)jarg3;
76706   {
76707     try {
76708       (arg1)->ScrollToItem(arg2,arg3);
76709     } catch (std::out_of_range& e) {
76710       {
76711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76712       };
76713     } catch (std::exception& e) {
76714       {
76715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76716       };
76717     } catch (Dali::DaliException e) {
76718       {
76719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76720       };
76721     } catch (...) {
76722       {
76723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76724       };
76725     }
76726   }
76727
76728 }
76729
76730
76731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76732   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76733   float arg2 ;
76734
76735   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76736   arg2 = (float)jarg2;
76737   {
76738     try {
76739       (arg1)->SetRefreshInterval(arg2);
76740     } catch (std::out_of_range& e) {
76741       {
76742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76743       };
76744     } catch (std::exception& e) {
76745       {
76746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76747       };
76748     } catch (Dali::DaliException e) {
76749       {
76750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76751       };
76752     } catch (...) {
76753       {
76754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76755       };
76756     }
76757   }
76758
76759 }
76760
76761
76762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76763   float jresult ;
76764   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76765   float result;
76766
76767   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76768   {
76769     try {
76770       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76771     } catch (std::out_of_range& e) {
76772       {
76773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76774       };
76775     } catch (std::exception& e) {
76776       {
76777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76778       };
76779     } catch (Dali::DaliException e) {
76780       {
76781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76782       };
76783     } catch (...) {
76784       {
76785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76786       };
76787     }
76788   }
76789
76790   jresult = result;
76791   return jresult;
76792 }
76793
76794
76795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76796   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76797
76798   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76799   {
76800     try {
76801       (arg1)->Refresh();
76802     } catch (std::out_of_range& e) {
76803       {
76804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76805       };
76806     } catch (std::exception& e) {
76807       {
76808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76809       };
76810     } catch (Dali::DaliException e) {
76811       {
76812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76813       };
76814     } catch (...) {
76815       {
76816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76817       };
76818     }
76819   }
76820
76821 }
76822
76823
76824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76825   void * jresult ;
76826   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76827   Dali::Toolkit::ItemId arg2 ;
76828   Dali::Actor result;
76829
76830   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76831   arg2 = (Dali::Toolkit::ItemId)jarg2;
76832   {
76833     try {
76834       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76835     } catch (std::out_of_range& e) {
76836       {
76837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76838       };
76839     } catch (std::exception& e) {
76840       {
76841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76842       };
76843     } catch (Dali::DaliException e) {
76844       {
76845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76846       };
76847     } catch (...) {
76848       {
76849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76850       };
76851     }
76852   }
76853
76854   jresult = new Dali::Actor((const Dali::Actor &)result);
76855   return jresult;
76856 }
76857
76858
76859 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76860   unsigned int jresult ;
76861   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76862   Dali::Actor arg2 ;
76863   Dali::Actor *argp2 ;
76864   Dali::Toolkit::ItemId result;
76865
76866   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76867   argp2 = (Dali::Actor *)jarg2;
76868   if (!argp2) {
76869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76870     return 0;
76871   }
76872   arg2 = *argp2;
76873   {
76874     try {
76875       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76876     } catch (std::out_of_range& e) {
76877       {
76878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76879       };
76880     } catch (std::exception& e) {
76881       {
76882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76883       };
76884     } catch (Dali::DaliException e) {
76885       {
76886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76887       };
76888     } catch (...) {
76889       {
76890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76891       };
76892     }
76893   }
76894
76895   jresult = result;
76896   return jresult;
76897 }
76898
76899
76900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76901   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76902   Dali::Toolkit::Item arg2 ;
76903   float arg3 ;
76904   Dali::Toolkit::Item *argp2 ;
76905
76906   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76907   argp2 = (Dali::Toolkit::Item *)jarg2;
76908   if (!argp2) {
76909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76910     return ;
76911   }
76912   arg2 = *argp2;
76913   arg3 = (float)jarg3;
76914   {
76915     try {
76916       (arg1)->InsertItem(arg2,arg3);
76917     } catch (std::out_of_range& e) {
76918       {
76919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76920       };
76921     } catch (std::exception& e) {
76922       {
76923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76924       };
76925     } catch (Dali::DaliException e) {
76926       {
76927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76928       };
76929     } catch (...) {
76930       {
76931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76932       };
76933     }
76934   }
76935
76936 }
76937
76938
76939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76940   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76941   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76942   float arg3 ;
76943
76944   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76945   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76946   if (!arg2) {
76947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76948     return ;
76949   }
76950   arg3 = (float)jarg3;
76951   {
76952     try {
76953       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76954     } catch (std::out_of_range& e) {
76955       {
76956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76957       };
76958     } catch (std::exception& e) {
76959       {
76960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76961       };
76962     } catch (Dali::DaliException e) {
76963       {
76964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76965       };
76966     } catch (...) {
76967       {
76968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76969       };
76970     }
76971   }
76972
76973 }
76974
76975
76976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76977   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76978   Dali::Toolkit::ItemId arg2 ;
76979   float arg3 ;
76980
76981   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76982   arg2 = (Dali::Toolkit::ItemId)jarg2;
76983   arg3 = (float)jarg3;
76984   {
76985     try {
76986       (arg1)->RemoveItem(arg2,arg3);
76987     } catch (std::out_of_range& e) {
76988       {
76989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76990       };
76991     } catch (std::exception& e) {
76992       {
76993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76994       };
76995     } catch (Dali::DaliException e) {
76996       {
76997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76998       };
76999     } catch (...) {
77000       {
77001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77002       };
77003     }
77004   }
77005
77006 }
77007
77008
77009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77010   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77011   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77012   float arg3 ;
77013
77014   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77015   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77016   if (!arg2) {
77017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77018     return ;
77019   }
77020   arg3 = (float)jarg3;
77021   {
77022     try {
77023       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77024     } catch (std::out_of_range& e) {
77025       {
77026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77027       };
77028     } catch (std::exception& e) {
77029       {
77030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77031       };
77032     } catch (Dali::DaliException e) {
77033       {
77034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77035       };
77036     } catch (...) {
77037       {
77038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77039       };
77040     }
77041   }
77042
77043 }
77044
77045
77046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77047   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77048   Dali::Toolkit::Item arg2 ;
77049   float arg3 ;
77050   Dali::Toolkit::Item *argp2 ;
77051
77052   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77053   argp2 = (Dali::Toolkit::Item *)jarg2;
77054   if (!argp2) {
77055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77056     return ;
77057   }
77058   arg2 = *argp2;
77059   arg3 = (float)jarg3;
77060   {
77061     try {
77062       (arg1)->ReplaceItem(arg2,arg3);
77063     } catch (std::out_of_range& e) {
77064       {
77065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77066       };
77067     } catch (std::exception& e) {
77068       {
77069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77070       };
77071     } catch (Dali::DaliException e) {
77072       {
77073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77074       };
77075     } catch (...) {
77076       {
77077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77078       };
77079     }
77080   }
77081
77082 }
77083
77084
77085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77086   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77087   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77088   float arg3 ;
77089
77090   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77091   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77092   if (!arg2) {
77093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77094     return ;
77095   }
77096   arg3 = (float)jarg3;
77097   {
77098     try {
77099       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77100     } catch (std::out_of_range& e) {
77101       {
77102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77103       };
77104     } catch (std::exception& e) {
77105       {
77106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77107       };
77108     } catch (Dali::DaliException e) {
77109       {
77110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77111       };
77112     } catch (...) {
77113       {
77114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77115       };
77116     }
77117   }
77118
77119 }
77120
77121
77122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77123   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77124   Dali::Vector3 *arg2 = 0 ;
77125
77126   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77127   arg2 = (Dali::Vector3 *)jarg2;
77128   if (!arg2) {
77129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77130     return ;
77131   }
77132   {
77133     try {
77134       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77135     } catch (std::out_of_range& e) {
77136       {
77137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77138       };
77139     } catch (std::exception& e) {
77140       {
77141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77142       };
77143     } catch (Dali::DaliException e) {
77144       {
77145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77146       };
77147     } catch (...) {
77148       {
77149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77150       };
77151     }
77152   }
77153
77154 }
77155
77156
77157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77158   void * jresult ;
77159   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77160   Dali::Vector3 result;
77161
77162   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77163   {
77164     try {
77165       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77166     } catch (std::out_of_range& e) {
77167       {
77168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77169       };
77170     } catch (std::exception& e) {
77171       {
77172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77173       };
77174     } catch (Dali::DaliException e) {
77175       {
77176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77177       };
77178     } catch (...) {
77179       {
77180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77181       };
77182     }
77183   }
77184
77185   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77186   return jresult;
77187 }
77188
77189
77190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77191   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77192   Dali::Vector3 *arg2 = 0 ;
77193
77194   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77195   arg2 = (Dali::Vector3 *)jarg2;
77196   if (!arg2) {
77197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77198     return ;
77199   }
77200   {
77201     try {
77202       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77203     } catch (std::out_of_range& e) {
77204       {
77205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77206       };
77207     } catch (std::exception& e) {
77208       {
77209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77210       };
77211     } catch (Dali::DaliException e) {
77212       {
77213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77214       };
77215     } catch (...) {
77216       {
77217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77218       };
77219     }
77220   }
77221
77222 }
77223
77224
77225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77226   void * jresult ;
77227   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77228   Dali::Vector3 result;
77229
77230   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77231   {
77232     try {
77233       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77234     } catch (std::out_of_range& e) {
77235       {
77236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77237       };
77238     } catch (std::exception& e) {
77239       {
77240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77241       };
77242     } catch (Dali::DaliException e) {
77243       {
77244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77245       };
77246     } catch (...) {
77247       {
77248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77249       };
77250     }
77251   }
77252
77253   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77254   return jresult;
77255 }
77256
77257
77258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77259   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77260   Dali::Toolkit::ItemRange *arg2 = 0 ;
77261
77262   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77263   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77264   if (!arg2) {
77265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77266     return ;
77267   }
77268   {
77269     try {
77270       (arg1)->GetItemsRange(*arg2);
77271     } catch (std::out_of_range& e) {
77272       {
77273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77274       };
77275     } catch (std::exception& e) {
77276       {
77277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77278       };
77279     } catch (Dali::DaliException e) {
77280       {
77281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77282       };
77283     } catch (...) {
77284       {
77285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77286       };
77287     }
77288   }
77289
77290 }
77291
77292
77293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77294   void * jresult ;
77295   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77296   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77297
77298   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77299   {
77300     try {
77301       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77302     } catch (std::out_of_range& e) {
77303       {
77304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77305       };
77306     } catch (std::exception& e) {
77307       {
77308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77309       };
77310     } catch (Dali::DaliException e) {
77311       {
77312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77313       };
77314     } catch (...) {
77315       {
77316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77317       };
77318     }
77319   }
77320
77321   jresult = (void *)result;
77322   return jresult;
77323 }
77324
77325
77326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77327   Dali::Vector3 *arg1 = 0 ;
77328   PropertyInputContainer *arg2 = 0 ;
77329
77330   arg1 = (Dali::Vector3 *)jarg1;
77331   if (!arg1) {
77332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77333     return ;
77334   }
77335   arg2 = (PropertyInputContainer *)jarg2;
77336   if (!arg2) {
77337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77338     return ;
77339   }
77340   {
77341     try {
77342       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77343     } catch (std::out_of_range& e) {
77344       {
77345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77346       };
77347     } catch (std::exception& e) {
77348       {
77349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77350       };
77351     } catch (Dali::DaliException e) {
77352       {
77353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77354       };
77355     } catch (...) {
77356       {
77357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77358       };
77359     }
77360   }
77361
77362 }
77363
77364
77365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77366   Dali::Vector3 *arg1 = 0 ;
77367   PropertyInputContainer *arg2 = 0 ;
77368
77369   arg1 = (Dali::Vector3 *)jarg1;
77370   if (!arg1) {
77371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77372     return ;
77373   }
77374   arg2 = (PropertyInputContainer *)jarg2;
77375   if (!arg2) {
77376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77377     return ;
77378   }
77379   {
77380     try {
77381       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77382     } catch (std::out_of_range& e) {
77383       {
77384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77385       };
77386     } catch (std::exception& e) {
77387       {
77388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77389       };
77390     } catch (Dali::DaliException e) {
77391       {
77392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77393       };
77394     } catch (...) {
77395       {
77396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77397       };
77398     }
77399   }
77400
77401 }
77402
77403
77404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77405   void * jresult ;
77406   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77407
77408   {
77409     try {
77410       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77411     } catch (std::out_of_range& e) {
77412       {
77413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77414       };
77415     } catch (std::exception& e) {
77416       {
77417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77418       };
77419     } catch (Dali::DaliException e) {
77420       {
77421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77422       };
77423     } catch (...) {
77424       {
77425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77426       };
77427     }
77428   }
77429
77430   jresult = (void *)result;
77431   return jresult;
77432 }
77433
77434
77435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77436   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77437
77438   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77439   {
77440     try {
77441       delete arg1;
77442     } catch (std::out_of_range& e) {
77443       {
77444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77445       };
77446     } catch (std::exception& e) {
77447       {
77448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77449       };
77450     } catch (Dali::DaliException e) {
77451       {
77452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77453       };
77454     } catch (...) {
77455       {
77456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77457       };
77458     }
77459   }
77460
77461 }
77462
77463
77464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77465   void * jresult ;
77466   Dali::Path arg1 ;
77467   Dali::Vector3 *arg2 = 0 ;
77468   Dali::Property::Index arg3 ;
77469   Dali::Vector3 *arg4 = 0 ;
77470   unsigned int arg5 ;
77471   Dali::Path *argp1 ;
77472   Dali::Toolkit::ScrollViewPagePathEffect result;
77473
77474   argp1 = (Dali::Path *)jarg1;
77475   if (!argp1) {
77476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77477     return 0;
77478   }
77479   arg1 = *argp1;
77480   arg2 = (Dali::Vector3 *)jarg2;
77481   if (!arg2) {
77482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77483     return 0;
77484   }
77485   arg3 = (Dali::Property::Index)jarg3;
77486   arg4 = (Dali::Vector3 *)jarg4;
77487   if (!arg4) {
77488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77489     return 0;
77490   }
77491   arg5 = (unsigned int)jarg5;
77492   {
77493     try {
77494       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77495     } catch (std::out_of_range& e) {
77496       {
77497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77498       };
77499     } catch (std::exception& e) {
77500       {
77501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77502       };
77503     } catch (Dali::DaliException e) {
77504       {
77505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77506       };
77507     } catch (...) {
77508       {
77509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77510       };
77511     }
77512   }
77513
77514   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77515   return jresult;
77516 }
77517
77518
77519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77520   void * jresult ;
77521   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77522
77523   {
77524     try {
77525       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77526     } catch (std::out_of_range& e) {
77527       {
77528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77529       };
77530     } catch (std::exception& e) {
77531       {
77532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77533       };
77534     } catch (Dali::DaliException e) {
77535       {
77536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77537       };
77538     } catch (...) {
77539       {
77540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77541       };
77542     }
77543   }
77544
77545   jresult = (void *)result;
77546   return jresult;
77547 }
77548
77549
77550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77551   void * jresult ;
77552   Dali::BaseHandle arg1 ;
77553   Dali::BaseHandle *argp1 ;
77554   Dali::Toolkit::ScrollViewPagePathEffect result;
77555
77556   argp1 = (Dali::BaseHandle *)jarg1;
77557   if (!argp1) {
77558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77559     return 0;
77560   }
77561   arg1 = *argp1;
77562   {
77563     try {
77564       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77565     } catch (std::out_of_range& e) {
77566       {
77567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77568       };
77569     } catch (std::exception& e) {
77570       {
77571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77572       };
77573     } catch (Dali::DaliException e) {
77574       {
77575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77576       };
77577     } catch (...) {
77578       {
77579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77580       };
77581     }
77582   }
77583
77584   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77585   return jresult;
77586 }
77587
77588
77589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77590   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77591   Dali::Actor arg2 ;
77592   unsigned int arg3 ;
77593   Dali::Actor *argp2 ;
77594
77595   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77596   argp2 = (Dali::Actor *)jarg2;
77597   if (!argp2) {
77598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77599     return ;
77600   }
77601   arg2 = *argp2;
77602   arg3 = (unsigned int)jarg3;
77603   {
77604     try {
77605       (arg1)->ApplyToPage(arg2,arg3);
77606     } catch (std::out_of_range& e) {
77607       {
77608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77609       };
77610     } catch (std::exception& e) {
77611       {
77612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77613       };
77614     } catch (Dali::DaliException e) {
77615       {
77616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77617       };
77618     } catch (...) {
77619       {
77620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77621       };
77622     }
77623   }
77624
77625 }
77626
77627
77628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77629   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77630
77631   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77632   {
77633     try {
77634       delete arg1;
77635     } catch (std::out_of_range& e) {
77636       {
77637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77638       };
77639     } catch (std::exception& e) {
77640       {
77641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77642       };
77643     } catch (Dali::DaliException e) {
77644       {
77645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77646       };
77647     } catch (...) {
77648       {
77649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77650       };
77651     }
77652   }
77653
77654 }
77655
77656
77657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77658   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77659   Dali::Toolkit::ClampState arg2 ;
77660
77661   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77662   arg2 = (Dali::Toolkit::ClampState)jarg2;
77663   if (arg1) (arg1)->x = arg2;
77664 }
77665
77666
77667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77668   int jresult ;
77669   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77670   Dali::Toolkit::ClampState result;
77671
77672   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77673   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77674   jresult = (int)result;
77675   return jresult;
77676 }
77677
77678
77679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77680   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77681   Dali::Toolkit::ClampState arg2 ;
77682
77683   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77684   arg2 = (Dali::Toolkit::ClampState)jarg2;
77685   if (arg1) (arg1)->y = arg2;
77686 }
77687
77688
77689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77690   int jresult ;
77691   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77692   Dali::Toolkit::ClampState result;
77693
77694   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77695   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77696   jresult = (int)result;
77697   return jresult;
77698 }
77699
77700
77701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77702   void * jresult ;
77703   Dali::Toolkit::ClampState2D *result = 0 ;
77704
77705   {
77706     try {
77707       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77708     } catch (std::out_of_range& e) {
77709       {
77710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77711       };
77712     } catch (std::exception& e) {
77713       {
77714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77715       };
77716     } catch (Dali::DaliException e) {
77717       {
77718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77719       };
77720     } catch (...) {
77721       {
77722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77723       };
77724     }
77725   }
77726
77727   jresult = (void *)result;
77728   return jresult;
77729 }
77730
77731
77732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77733   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77734
77735   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77736   {
77737     try {
77738       delete arg1;
77739     } catch (std::out_of_range& e) {
77740       {
77741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77742       };
77743     } catch (std::exception& e) {
77744       {
77745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77746       };
77747     } catch (Dali::DaliException e) {
77748       {
77749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77750       };
77751     } catch (...) {
77752       {
77753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77754       };
77755     }
77756   }
77757
77758 }
77759
77760
77761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77762   void * jresult ;
77763   float arg1 ;
77764   float arg2 ;
77765   bool arg3 ;
77766   Dali::Toolkit::RulerDomain *result = 0 ;
77767
77768   arg1 = (float)jarg1;
77769   arg2 = (float)jarg2;
77770   arg3 = jarg3 ? true : false;
77771   {
77772     try {
77773       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77774     } catch (std::out_of_range& e) {
77775       {
77776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77777       };
77778     } catch (std::exception& e) {
77779       {
77780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77781       };
77782     } catch (Dali::DaliException e) {
77783       {
77784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77785       };
77786     } catch (...) {
77787       {
77788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77789       };
77790     }
77791   }
77792
77793   jresult = (void *)result;
77794   return jresult;
77795 }
77796
77797
77798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77799   void * jresult ;
77800   float arg1 ;
77801   float arg2 ;
77802   Dali::Toolkit::RulerDomain *result = 0 ;
77803
77804   arg1 = (float)jarg1;
77805   arg2 = (float)jarg2;
77806   {
77807     try {
77808       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77809     } catch (std::out_of_range& e) {
77810       {
77811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77812       };
77813     } catch (std::exception& e) {
77814       {
77815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77816       };
77817     } catch (Dali::DaliException e) {
77818       {
77819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77820       };
77821     } catch (...) {
77822       {
77823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77824       };
77825     }
77826   }
77827
77828   jresult = (void *)result;
77829   return jresult;
77830 }
77831
77832
77833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77834   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77835   float arg2 ;
77836
77837   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77838   arg2 = (float)jarg2;
77839   if (arg1) (arg1)->min = arg2;
77840 }
77841
77842
77843 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77844   float jresult ;
77845   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77846   float result;
77847
77848   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77849   result = (float) ((arg1)->min);
77850   jresult = result;
77851   return jresult;
77852 }
77853
77854
77855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77856   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77857   float arg2 ;
77858
77859   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77860   arg2 = (float)jarg2;
77861   if (arg1) (arg1)->max = arg2;
77862 }
77863
77864
77865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77866   float jresult ;
77867   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77868   float result;
77869
77870   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77871   result = (float) ((arg1)->max);
77872   jresult = result;
77873   return jresult;
77874 }
77875
77876
77877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77878   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77879   bool arg2 ;
77880
77881   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77882   arg2 = jarg2 ? true : false;
77883   if (arg1) (arg1)->enabled = arg2;
77884 }
77885
77886
77887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77888   unsigned int jresult ;
77889   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77890   bool result;
77891
77892   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77893   result = (bool) ((arg1)->enabled);
77894   jresult = result;
77895   return jresult;
77896 }
77897
77898
77899 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77900   float jresult ;
77901   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77902   float arg2 ;
77903   float arg3 ;
77904   float arg4 ;
77905   float result;
77906
77907   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77908   arg2 = (float)jarg2;
77909   arg3 = (float)jarg3;
77910   arg4 = (float)jarg4;
77911   {
77912     try {
77913       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77914     } catch (std::out_of_range& e) {
77915       {
77916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77917       };
77918     } catch (std::exception& e) {
77919       {
77920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77921       };
77922     } catch (Dali::DaliException e) {
77923       {
77924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77925       };
77926     } catch (...) {
77927       {
77928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77929       };
77930     }
77931   }
77932
77933   jresult = result;
77934   return jresult;
77935 }
77936
77937
77938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77939   float jresult ;
77940   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77941   float arg2 ;
77942   float arg3 ;
77943   float result;
77944
77945   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77946   arg2 = (float)jarg2;
77947   arg3 = (float)jarg3;
77948   {
77949     try {
77950       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77951     } catch (std::out_of_range& e) {
77952       {
77953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77954       };
77955     } catch (std::exception& e) {
77956       {
77957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77958       };
77959     } catch (Dali::DaliException e) {
77960       {
77961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77962       };
77963     } catch (...) {
77964       {
77965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77966       };
77967     }
77968   }
77969
77970   jresult = result;
77971   return jresult;
77972 }
77973
77974
77975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77976   float jresult ;
77977   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77978   float arg2 ;
77979   float result;
77980
77981   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77982   arg2 = (float)jarg2;
77983   {
77984     try {
77985       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77986     } catch (std::out_of_range& e) {
77987       {
77988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77989       };
77990     } catch (std::exception& e) {
77991       {
77992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77993       };
77994     } catch (Dali::DaliException e) {
77995       {
77996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77997       };
77998     } catch (...) {
77999       {
78000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78001       };
78002     }
78003   }
78004
78005   jresult = result;
78006   return jresult;
78007 }
78008
78009
78010 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78011   float jresult ;
78012   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78013   float arg2 ;
78014   float arg3 ;
78015   float arg4 ;
78016   Dali::Toolkit::ClampState *arg5 = 0 ;
78017   float result;
78018
78019   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78020   arg2 = (float)jarg2;
78021   arg3 = (float)jarg3;
78022   arg4 = (float)jarg4;
78023   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78024   if (!arg5) {
78025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78026     return 0;
78027   }
78028   {
78029     try {
78030       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78031     } catch (std::out_of_range& e) {
78032       {
78033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78034       };
78035     } catch (std::exception& e) {
78036       {
78037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78038       };
78039     } catch (Dali::DaliException e) {
78040       {
78041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78042       };
78043     } catch (...) {
78044       {
78045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78046       };
78047     }
78048   }
78049
78050   jresult = result;
78051   return jresult;
78052 }
78053
78054
78055 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78056   float jresult ;
78057   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78058   float result;
78059
78060   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78061   {
78062     try {
78063       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78064     } catch (std::out_of_range& e) {
78065       {
78066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78067       };
78068     } catch (std::exception& e) {
78069       {
78070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78071       };
78072     } catch (Dali::DaliException e) {
78073       {
78074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78075       };
78076     } catch (...) {
78077       {
78078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78079       };
78080     }
78081   }
78082
78083   jresult = result;
78084   return jresult;
78085 }
78086
78087
78088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78089   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78090
78091   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78092   {
78093     try {
78094       delete arg1;
78095     } catch (std::out_of_range& e) {
78096       {
78097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78098       };
78099     } catch (std::exception& e) {
78100       {
78101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78102       };
78103     } catch (Dali::DaliException e) {
78104       {
78105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78106       };
78107     } catch (...) {
78108       {
78109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78110       };
78111     }
78112   }
78113
78114 }
78115
78116
78117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78118   float jresult ;
78119   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78120   float arg2 ;
78121   float arg3 ;
78122   float result;
78123
78124   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78125   arg2 = (float)jarg2;
78126   arg3 = (float)jarg3;
78127   {
78128     try {
78129       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78130     } catch (std::out_of_range& e) {
78131       {
78132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78133       };
78134     } catch (std::exception& e) {
78135       {
78136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78137       };
78138     } catch (Dali::DaliException e) {
78139       {
78140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78141       };
78142     } catch (...) {
78143       {
78144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78145       };
78146     }
78147   }
78148
78149   jresult = result;
78150   return jresult;
78151 }
78152
78153
78154 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78155   float jresult ;
78156   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78157   float arg2 ;
78158   float result;
78159
78160   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78161   arg2 = (float)jarg2;
78162   {
78163     try {
78164       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78165     } catch (std::out_of_range& e) {
78166       {
78167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78168       };
78169     } catch (std::exception& e) {
78170       {
78171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78172       };
78173     } catch (Dali::DaliException e) {
78174       {
78175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78176       };
78177     } catch (...) {
78178       {
78179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78180       };
78181     }
78182   }
78183
78184   jresult = result;
78185   return jresult;
78186 }
78187
78188
78189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78190   float jresult ;
78191   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78192   unsigned int arg2 ;
78193   unsigned int *arg3 = 0 ;
78194   bool arg4 ;
78195   float result;
78196
78197   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78198   arg2 = (unsigned int)jarg2;
78199   arg3 = (unsigned int *)jarg3;
78200   arg4 = jarg4 ? true : false;
78201   {
78202     try {
78203       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78204     } catch (std::out_of_range& e) {
78205       {
78206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78207       };
78208     } catch (std::exception& e) {
78209       {
78210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78211       };
78212     } catch (Dali::DaliException e) {
78213       {
78214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78215       };
78216     } catch (...) {
78217       {
78218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78219       };
78220     }
78221   }
78222
78223   jresult = result;
78224   return jresult;
78225 }
78226
78227
78228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78229   unsigned int jresult ;
78230   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78231   float arg2 ;
78232   bool arg3 ;
78233   unsigned int result;
78234
78235   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78236   arg2 = (float)jarg2;
78237   arg3 = jarg3 ? true : false;
78238   {
78239     try {
78240       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78241     } catch (std::out_of_range& e) {
78242       {
78243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78244       };
78245     } catch (std::exception& e) {
78246       {
78247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78248       };
78249     } catch (Dali::DaliException e) {
78250       {
78251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78252       };
78253     } catch (...) {
78254       {
78255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78256       };
78257     }
78258   }
78259
78260   jresult = result;
78261   return jresult;
78262 }
78263
78264
78265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78266   unsigned int jresult ;
78267   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78268   unsigned int result;
78269
78270   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78271   {
78272     try {
78273       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78274     } catch (std::out_of_range& e) {
78275       {
78276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78277       };
78278     } catch (std::exception& e) {
78279       {
78280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78281       };
78282     } catch (Dali::DaliException e) {
78283       {
78284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78285       };
78286     } catch (...) {
78287       {
78288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78289       };
78290     }
78291   }
78292
78293   jresult = result;
78294   return jresult;
78295 }
78296
78297
78298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78299   int jresult ;
78300   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78301   Dali::Toolkit::Ruler::RulerType result;
78302
78303   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78304   {
78305     try {
78306       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78307     } catch (std::out_of_range& e) {
78308       {
78309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78310       };
78311     } catch (std::exception& e) {
78312       {
78313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78314       };
78315     } catch (Dali::DaliException e) {
78316       {
78317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78318       };
78319     } catch (...) {
78320       {
78321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78322       };
78323     }
78324   }
78325
78326   jresult = (int)result;
78327   return jresult;
78328 }
78329
78330
78331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78332   unsigned int jresult ;
78333   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78334   bool result;
78335
78336   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78337   {
78338     try {
78339       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78340     } catch (std::out_of_range& e) {
78341       {
78342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78343       };
78344     } catch (std::exception& e) {
78345       {
78346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78347       };
78348     } catch (Dali::DaliException e) {
78349       {
78350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78351       };
78352     } catch (...) {
78353       {
78354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78355       };
78356     }
78357   }
78358
78359   jresult = result;
78360   return jresult;
78361 }
78362
78363
78364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78365   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78366
78367   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78368   {
78369     try {
78370       (arg1)->Enable();
78371     } catch (std::out_of_range& e) {
78372       {
78373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78374       };
78375     } catch (std::exception& e) {
78376       {
78377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78378       };
78379     } catch (Dali::DaliException e) {
78380       {
78381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78382       };
78383     } catch (...) {
78384       {
78385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78386       };
78387     }
78388   }
78389
78390 }
78391
78392
78393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78394   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78395
78396   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78397   {
78398     try {
78399       (arg1)->Disable();
78400     } catch (std::out_of_range& e) {
78401       {
78402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78403       };
78404     } catch (std::exception& e) {
78405       {
78406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78407       };
78408     } catch (Dali::DaliException e) {
78409       {
78410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78411       };
78412     } catch (...) {
78413       {
78414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78415       };
78416     }
78417   }
78418
78419 }
78420
78421
78422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78423   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78424   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78425   Dali::Toolkit::RulerDomain *argp2 ;
78426
78427   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78428   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78429   if (!argp2) {
78430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78431     return ;
78432   }
78433   arg2 = *argp2;
78434   {
78435     try {
78436       (arg1)->SetDomain(arg2);
78437     } catch (std::out_of_range& e) {
78438       {
78439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78440       };
78441     } catch (std::exception& e) {
78442       {
78443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78444       };
78445     } catch (Dali::DaliException e) {
78446       {
78447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78448       };
78449     } catch (...) {
78450       {
78451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78452       };
78453     }
78454   }
78455
78456 }
78457
78458
78459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78460   void * jresult ;
78461   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78462   Dali::Toolkit::RulerDomain *result = 0 ;
78463
78464   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78465   {
78466     try {
78467       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78468     } catch (std::out_of_range& e) {
78469       {
78470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78471       };
78472     } catch (std::exception& e) {
78473       {
78474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78475       };
78476     } catch (Dali::DaliException e) {
78477       {
78478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78479       };
78480     } catch (...) {
78481       {
78482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78483       };
78484     }
78485   }
78486
78487   jresult = (void *)result;
78488   return jresult;
78489 }
78490
78491
78492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78493   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78494
78495   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78496   {
78497     try {
78498       (arg1)->DisableDomain();
78499     } catch (std::out_of_range& e) {
78500       {
78501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78502       };
78503     } catch (std::exception& e) {
78504       {
78505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78506       };
78507     } catch (Dali::DaliException e) {
78508       {
78509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78510       };
78511     } catch (...) {
78512       {
78513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78514       };
78515     }
78516   }
78517
78518 }
78519
78520
78521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78522   float jresult ;
78523   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78524   float arg2 ;
78525   float arg3 ;
78526   float arg4 ;
78527   float result;
78528
78529   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78530   arg2 = (float)jarg2;
78531   arg3 = (float)jarg3;
78532   arg4 = (float)jarg4;
78533   {
78534     try {
78535       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78536     } catch (std::out_of_range& e) {
78537       {
78538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78539       };
78540     } catch (std::exception& e) {
78541       {
78542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78543       };
78544     } catch (Dali::DaliException e) {
78545       {
78546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78547       };
78548     } catch (...) {
78549       {
78550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78551       };
78552     }
78553   }
78554
78555   jresult = result;
78556   return jresult;
78557 }
78558
78559
78560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78561   float jresult ;
78562   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78563   float arg2 ;
78564   float arg3 ;
78565   float result;
78566
78567   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78568   arg2 = (float)jarg2;
78569   arg3 = (float)jarg3;
78570   {
78571     try {
78572       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78573     } catch (std::out_of_range& e) {
78574       {
78575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78576       };
78577     } catch (std::exception& e) {
78578       {
78579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78580       };
78581     } catch (Dali::DaliException e) {
78582       {
78583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78584       };
78585     } catch (...) {
78586       {
78587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78588       };
78589     }
78590   }
78591
78592   jresult = result;
78593   return jresult;
78594 }
78595
78596
78597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78598   float jresult ;
78599   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78600   float arg2 ;
78601   float result;
78602
78603   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78604   arg2 = (float)jarg2;
78605   {
78606     try {
78607       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78608     } catch (std::out_of_range& e) {
78609       {
78610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78611       };
78612     } catch (std::exception& e) {
78613       {
78614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78615       };
78616     } catch (Dali::DaliException e) {
78617       {
78618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78619       };
78620     } catch (...) {
78621       {
78622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78623       };
78624     }
78625   }
78626
78627   jresult = result;
78628   return jresult;
78629 }
78630
78631
78632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78633   float jresult ;
78634   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78635   float arg2 ;
78636   float arg3 ;
78637   float arg4 ;
78638   Dali::Toolkit::ClampState *arg5 = 0 ;
78639   float result;
78640
78641   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78642   arg2 = (float)jarg2;
78643   arg3 = (float)jarg3;
78644   arg4 = (float)jarg4;
78645   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78646   if (!arg5) {
78647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78648     return 0;
78649   }
78650   {
78651     try {
78652       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78653     } catch (std::out_of_range& e) {
78654       {
78655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78656       };
78657     } catch (std::exception& e) {
78658       {
78659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78660       };
78661     } catch (Dali::DaliException e) {
78662       {
78663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78664       };
78665     } catch (...) {
78666       {
78667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78668       };
78669     }
78670   }
78671
78672   jresult = result;
78673   return jresult;
78674 }
78675
78676
78677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78678   float jresult ;
78679   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78680   float arg2 ;
78681   float arg3 ;
78682   float arg4 ;
78683   float arg5 ;
78684   float result;
78685
78686   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78687   arg2 = (float)jarg2;
78688   arg3 = (float)jarg3;
78689   arg4 = (float)jarg4;
78690   arg5 = (float)jarg5;
78691   {
78692     try {
78693       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78694     } catch (std::out_of_range& e) {
78695       {
78696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78697       };
78698     } catch (std::exception& e) {
78699       {
78700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78701       };
78702     } catch (Dali::DaliException e) {
78703       {
78704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78705       };
78706     } catch (...) {
78707       {
78708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78709       };
78710     }
78711   }
78712
78713   jresult = result;
78714   return jresult;
78715 }
78716
78717
78718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78719   float jresult ;
78720   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78721   float arg2 ;
78722   float arg3 ;
78723   float arg4 ;
78724   float result;
78725
78726   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78727   arg2 = (float)jarg2;
78728   arg3 = (float)jarg3;
78729   arg4 = (float)jarg4;
78730   {
78731     try {
78732       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78733     } catch (std::out_of_range& e) {
78734       {
78735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78736       };
78737     } catch (std::exception& e) {
78738       {
78739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78740       };
78741     } catch (Dali::DaliException e) {
78742       {
78743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78744       };
78745     } catch (...) {
78746       {
78747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78748       };
78749     }
78750   }
78751
78752   jresult = result;
78753   return jresult;
78754 }
78755
78756
78757 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78758   float jresult ;
78759   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78760   float arg2 ;
78761   float arg3 ;
78762   float result;
78763
78764   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78765   arg2 = (float)jarg2;
78766   arg3 = (float)jarg3;
78767   {
78768     try {
78769       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78770     } catch (std::out_of_range& e) {
78771       {
78772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78773       };
78774     } catch (std::exception& e) {
78775       {
78776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78777       };
78778     } catch (Dali::DaliException e) {
78779       {
78780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78781       };
78782     } catch (...) {
78783       {
78784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78785       };
78786     }
78787   }
78788
78789   jresult = result;
78790   return jresult;
78791 }
78792
78793
78794 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78795   float jresult ;
78796   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78797   float arg2 ;
78798   float result;
78799
78800   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78801   arg2 = (float)jarg2;
78802   {
78803     try {
78804       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78805     } catch (std::out_of_range& e) {
78806       {
78807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78808       };
78809     } catch (std::exception& e) {
78810       {
78811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78812       };
78813     } catch (Dali::DaliException e) {
78814       {
78815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78816       };
78817     } catch (...) {
78818       {
78819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78820       };
78821     }
78822   }
78823
78824   jresult = result;
78825   return jresult;
78826 }
78827
78828
78829 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78830   float jresult ;
78831   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78832   float arg2 ;
78833   float arg3 ;
78834   float arg4 ;
78835   float arg5 ;
78836   Dali::Toolkit::ClampState *arg6 = 0 ;
78837   float result;
78838
78839   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78840   arg2 = (float)jarg2;
78841   arg3 = (float)jarg3;
78842   arg4 = (float)jarg4;
78843   arg5 = (float)jarg5;
78844   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78845   if (!arg6) {
78846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78847     return 0;
78848   }
78849   {
78850     try {
78851       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78852     } catch (std::out_of_range& e) {
78853       {
78854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78855       };
78856     } catch (std::exception& e) {
78857       {
78858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78859       };
78860     } catch (Dali::DaliException e) {
78861       {
78862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78863       };
78864     } catch (...) {
78865       {
78866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78867       };
78868     }
78869   }
78870
78871   jresult = result;
78872   return jresult;
78873 }
78874
78875
78876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78877   void * jresult ;
78878   Dali::Toolkit::DefaultRuler *result = 0 ;
78879
78880   {
78881     try {
78882       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78883     } catch (std::out_of_range& e) {
78884       {
78885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78886       };
78887     } catch (std::exception& e) {
78888       {
78889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78890       };
78891     } catch (Dali::DaliException e) {
78892       {
78893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78894       };
78895     } catch (...) {
78896       {
78897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78898       };
78899     }
78900   }
78901
78902   jresult = (void *)result;
78903   return jresult;
78904 }
78905
78906
78907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78908   float jresult ;
78909   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78910   float arg2 ;
78911   float arg3 ;
78912   float result;
78913
78914   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78915   arg2 = (float)jarg2;
78916   arg3 = (float)jarg3;
78917   {
78918     try {
78919       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78920     } catch (std::out_of_range& e) {
78921       {
78922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78923       };
78924     } catch (std::exception& e) {
78925       {
78926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78927       };
78928     } catch (Dali::DaliException e) {
78929       {
78930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78931       };
78932     } catch (...) {
78933       {
78934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78935       };
78936     }
78937   }
78938
78939   jresult = result;
78940   return jresult;
78941 }
78942
78943
78944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78945   float jresult ;
78946   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78947   unsigned int arg2 ;
78948   unsigned int *arg3 = 0 ;
78949   bool arg4 ;
78950   float result;
78951
78952   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78953   arg2 = (unsigned int)jarg2;
78954   arg3 = (unsigned int *)jarg3;
78955   arg4 = jarg4 ? true : false;
78956   {
78957     try {
78958       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78959     } catch (std::out_of_range& e) {
78960       {
78961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78962       };
78963     } catch (std::exception& e) {
78964       {
78965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78966       };
78967     } catch (Dali::DaliException e) {
78968       {
78969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78970       };
78971     } catch (...) {
78972       {
78973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78974       };
78975     }
78976   }
78977
78978   jresult = result;
78979   return jresult;
78980 }
78981
78982
78983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78984   unsigned int jresult ;
78985   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78986   float arg2 ;
78987   bool arg3 ;
78988   unsigned int result;
78989
78990   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78991   arg2 = (float)jarg2;
78992   arg3 = jarg3 ? true : false;
78993   {
78994     try {
78995       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78996     } catch (std::out_of_range& e) {
78997       {
78998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78999       };
79000     } catch (std::exception& e) {
79001       {
79002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79003       };
79004     } catch (Dali::DaliException e) {
79005       {
79006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79007       };
79008     } catch (...) {
79009       {
79010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79011       };
79012     }
79013   }
79014
79015   jresult = result;
79016   return jresult;
79017 }
79018
79019
79020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79021   unsigned int jresult ;
79022   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79023   unsigned int result;
79024
79025   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79026   {
79027     try {
79028       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79029     } catch (std::out_of_range& e) {
79030       {
79031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79032       };
79033     } catch (std::exception& e) {
79034       {
79035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79036       };
79037     } catch (Dali::DaliException e) {
79038       {
79039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79040       };
79041     } catch (...) {
79042       {
79043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79044       };
79045     }
79046   }
79047
79048   jresult = result;
79049   return jresult;
79050 }
79051
79052
79053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79054   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79055
79056   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79057   {
79058     try {
79059       delete arg1;
79060     } catch (std::out_of_range& e) {
79061       {
79062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79063       };
79064     } catch (std::exception& e) {
79065       {
79066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79067       };
79068     } catch (Dali::DaliException e) {
79069       {
79070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79071       };
79072     } catch (...) {
79073       {
79074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79075       };
79076     }
79077   }
79078
79079 }
79080
79081
79082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79083   void * jresult ;
79084   float arg1 ;
79085   Dali::Toolkit::FixedRuler *result = 0 ;
79086
79087   arg1 = (float)jarg1;
79088   {
79089     try {
79090       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79091     } catch (std::out_of_range& e) {
79092       {
79093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79094       };
79095     } catch (std::exception& e) {
79096       {
79097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79098       };
79099     } catch (Dali::DaliException e) {
79100       {
79101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79102       };
79103     } catch (...) {
79104       {
79105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79106       };
79107     }
79108   }
79109
79110   jresult = (void *)result;
79111   return jresult;
79112 }
79113
79114
79115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79116   void * jresult ;
79117   Dali::Toolkit::FixedRuler *result = 0 ;
79118
79119   {
79120     try {
79121       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79122     } catch (std::out_of_range& e) {
79123       {
79124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79125       };
79126     } catch (std::exception& e) {
79127       {
79128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79129       };
79130     } catch (Dali::DaliException e) {
79131       {
79132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79133       };
79134     } catch (...) {
79135       {
79136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79137       };
79138     }
79139   }
79140
79141   jresult = (void *)result;
79142   return jresult;
79143 }
79144
79145
79146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79147   float jresult ;
79148   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79149   float arg2 ;
79150   float arg3 ;
79151   float result;
79152
79153   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79154   arg2 = (float)jarg2;
79155   arg3 = (float)jarg3;
79156   {
79157     try {
79158       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79159     } catch (std::out_of_range& e) {
79160       {
79161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79162       };
79163     } catch (std::exception& e) {
79164       {
79165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79166       };
79167     } catch (Dali::DaliException e) {
79168       {
79169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79170       };
79171     } catch (...) {
79172       {
79173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79174       };
79175     }
79176   }
79177
79178   jresult = result;
79179   return jresult;
79180 }
79181
79182
79183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79184   float jresult ;
79185   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79186   unsigned int arg2 ;
79187   unsigned int *arg3 = 0 ;
79188   bool arg4 ;
79189   float result;
79190
79191   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79192   arg2 = (unsigned int)jarg2;
79193   arg3 = (unsigned int *)jarg3;
79194   arg4 = jarg4 ? true : false;
79195   {
79196     try {
79197       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79198     } catch (std::out_of_range& e) {
79199       {
79200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79201       };
79202     } catch (std::exception& e) {
79203       {
79204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79205       };
79206     } catch (Dali::DaliException e) {
79207       {
79208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79209       };
79210     } catch (...) {
79211       {
79212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79213       };
79214     }
79215   }
79216
79217   jresult = result;
79218   return jresult;
79219 }
79220
79221
79222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79223   unsigned int jresult ;
79224   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79225   float arg2 ;
79226   bool arg3 ;
79227   unsigned int result;
79228
79229   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79230   arg2 = (float)jarg2;
79231   arg3 = jarg3 ? true : false;
79232   {
79233     try {
79234       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79235     } catch (std::out_of_range& e) {
79236       {
79237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79238       };
79239     } catch (std::exception& e) {
79240       {
79241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79242       };
79243     } catch (Dali::DaliException e) {
79244       {
79245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79246       };
79247     } catch (...) {
79248       {
79249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79250       };
79251     }
79252   }
79253
79254   jresult = result;
79255   return jresult;
79256 }
79257
79258
79259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79260   unsigned int jresult ;
79261   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79262   unsigned int result;
79263
79264   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79265   {
79266     try {
79267       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79268     } catch (std::out_of_range& e) {
79269       {
79270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79271       };
79272     } catch (std::exception& e) {
79273       {
79274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79275       };
79276     } catch (Dali::DaliException e) {
79277       {
79278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79279       };
79280     } catch (...) {
79281       {
79282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79283       };
79284     }
79285   }
79286
79287   jresult = result;
79288   return jresult;
79289 }
79290
79291
79292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79293   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79294
79295   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79296   {
79297     try {
79298       delete arg1;
79299     } catch (std::out_of_range& e) {
79300       {
79301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79302       };
79303     } catch (std::exception& e) {
79304       {
79305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79306       };
79307     } catch (Dali::DaliException e) {
79308       {
79309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79310       };
79311     } catch (...) {
79312       {
79313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79314       };
79315     }
79316   }
79317
79318 }
79319
79320
79321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79322   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79323   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79324
79325   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79326   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79327   if (arg1) (arg1)->scale = *arg2;
79328 }
79329
79330
79331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79332   void * jresult ;
79333   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79334   Dali::Toolkit::ClampState2D *result = 0 ;
79335
79336   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79337   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79338   jresult = (void *)result;
79339   return jresult;
79340 }
79341
79342
79343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79344   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79345   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79346
79347   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79348   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79349   if (arg1) (arg1)->position = *arg2;
79350 }
79351
79352
79353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79354   void * jresult ;
79355   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79356   Dali::Toolkit::ClampState2D *result = 0 ;
79357
79358   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79359   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79360   jresult = (void *)result;
79361   return jresult;
79362 }
79363
79364
79365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79366   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79367   Dali::Toolkit::ClampState arg2 ;
79368
79369   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79370   arg2 = (Dali::Toolkit::ClampState)jarg2;
79371   if (arg1) (arg1)->rotation = arg2;
79372 }
79373
79374
79375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79376   int jresult ;
79377   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79378   Dali::Toolkit::ClampState result;
79379
79380   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79381   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79382   jresult = (int)result;
79383   return jresult;
79384 }
79385
79386
79387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79388   void * jresult ;
79389   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79390
79391   {
79392     try {
79393       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79394     } catch (std::out_of_range& e) {
79395       {
79396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79397       };
79398     } catch (std::exception& e) {
79399       {
79400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79401       };
79402     } catch (Dali::DaliException e) {
79403       {
79404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79405       };
79406     } catch (...) {
79407       {
79408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79409       };
79410     }
79411   }
79412
79413   jresult = (void *)result;
79414   return jresult;
79415 }
79416
79417
79418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79419   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79420
79421   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79422   {
79423     try {
79424       delete arg1;
79425     } catch (std::out_of_range& e) {
79426       {
79427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79428       };
79429     } catch (std::exception& e) {
79430       {
79431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79432       };
79433     } catch (Dali::DaliException e) {
79434       {
79435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79436       };
79437     } catch (...) {
79438       {
79439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79440       };
79441     }
79442   }
79443
79444 }
79445
79446
79447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79448   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79449   Dali::Toolkit::SnapType arg2 ;
79450
79451   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79452   arg2 = (Dali::Toolkit::SnapType)jarg2;
79453   if (arg1) (arg1)->type = arg2;
79454 }
79455
79456
79457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79458   int jresult ;
79459   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79460   Dali::Toolkit::SnapType result;
79461
79462   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79463   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79464   jresult = (int)result;
79465   return jresult;
79466 }
79467
79468
79469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79470   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79471   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79472
79473   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79474   arg2 = (Dali::Vector2 *)jarg2;
79475   if (arg1) (arg1)->position = *arg2;
79476 }
79477
79478
79479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79480   void * jresult ;
79481   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79482   Dali::Vector2 *result = 0 ;
79483
79484   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79485   result = (Dali::Vector2 *)& ((arg1)->position);
79486   jresult = (void *)result;
79487   return jresult;
79488 }
79489
79490
79491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79492   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79493   float arg2 ;
79494
79495   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79496   arg2 = (float)jarg2;
79497   if (arg1) (arg1)->duration = arg2;
79498 }
79499
79500
79501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79502   float jresult ;
79503   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79504   float result;
79505
79506   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79507   result = (float) ((arg1)->duration);
79508   jresult = result;
79509   return jresult;
79510 }
79511
79512
79513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79514   void * jresult ;
79515   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79516
79517   {
79518     try {
79519       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79520     } catch (std::out_of_range& e) {
79521       {
79522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79523       };
79524     } catch (std::exception& e) {
79525       {
79526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79527       };
79528     } catch (Dali::DaliException e) {
79529       {
79530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79531       };
79532     } catch (...) {
79533       {
79534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79535       };
79536     }
79537   }
79538
79539   jresult = (void *)result;
79540   return jresult;
79541 }
79542
79543
79544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79545   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79546
79547   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79548   {
79549     try {
79550       delete arg1;
79551     } catch (std::out_of_range& e) {
79552       {
79553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79554       };
79555     } catch (std::exception& e) {
79556       {
79557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79558       };
79559     } catch (Dali::DaliException e) {
79560       {
79561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79562       };
79563     } catch (...) {
79564       {
79565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79566       };
79567     }
79568   }
79569
79570 }
79571
79572
79573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79574   int jresult ;
79575   int result;
79576
79577   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79578   jresult = (int)result;
79579   return jresult;
79580 }
79581
79582
79583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79584   int jresult ;
79585   int result;
79586
79587   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79588   jresult = (int)result;
79589   return jresult;
79590 }
79591
79592
79593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79594   int jresult ;
79595   int result;
79596
79597   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79598   jresult = (int)result;
79599   return jresult;
79600 }
79601
79602
79603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79604   int jresult ;
79605   int result;
79606
79607   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79608   jresult = (int)result;
79609   return jresult;
79610 }
79611
79612
79613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79614   int jresult ;
79615   int result;
79616
79617   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79618   jresult = (int)result;
79619   return jresult;
79620 }
79621
79622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79623   int jresult ;
79624   int result;
79625
79626   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79627   jresult = (int)result;
79628   return jresult;
79629 }
79630
79631
79632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79633   int jresult ;
79634   int result;
79635
79636   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79637   jresult = (int)result;
79638   return jresult;
79639 }
79640
79641
79642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79643   int jresult ;
79644   int result;
79645
79646   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79647   jresult = (int)result;
79648   return jresult;
79649 }
79650
79651
79652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79653   int jresult ;
79654   int result;
79655
79656   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79657   jresult = (int)result;
79658   return jresult;
79659 }
79660
79661
79662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79663   int jresult ;
79664   int result;
79665
79666   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79667   jresult = (int)result;
79668   return jresult;
79669 }
79670
79671
79672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79673   int jresult ;
79674   int result;
79675
79676   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79677   jresult = (int)result;
79678   return jresult;
79679 }
79680
79681
79682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79683   int jresult ;
79684   int result;
79685
79686   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79687   jresult = (int)result;
79688   return jresult;
79689 }
79690
79691
79692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79693   int jresult ;
79694   int result;
79695
79696   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79697   jresult = (int)result;
79698   return jresult;
79699 }
79700
79701
79702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79703   int jresult ;
79704   int result;
79705
79706   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79707   jresult = (int)result;
79708   return jresult;
79709 }
79710
79711
79712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79713   int jresult ;
79714   int result;
79715
79716   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79717   jresult = (int)result;
79718   return jresult;
79719 }
79720
79721
79722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79723   int jresult ;
79724   int result;
79725
79726   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79727   jresult = (int)result;
79728   return jresult;
79729 }
79730
79731
79732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79733   int jresult ;
79734   int result;
79735
79736   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79737   jresult = (int)result;
79738   return jresult;
79739 }
79740
79741
79742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79743   int jresult ;
79744   int result;
79745
79746   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79747   jresult = (int)result;
79748   return jresult;
79749 }
79750
79751
79752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79753   int jresult ;
79754   int result;
79755
79756   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79757   jresult = (int)result;
79758   return jresult;
79759 }
79760
79761
79762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79763   int jresult ;
79764   int result;
79765
79766   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79767   jresult = (int)result;
79768   return jresult;
79769 }
79770
79771
79772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79773   int jresult ;
79774   int result;
79775
79776   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79777   jresult = (int)result;
79778   return jresult;
79779 }
79780
79781
79782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79783   int jresult ;
79784   int result;
79785
79786   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79787   jresult = (int)result;
79788   return jresult;
79789 }
79790
79791
79792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79793   int jresult ;
79794   int result;
79795
79796   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79797   jresult = (int)result;
79798   return jresult;
79799 }
79800
79801
79802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79803   int jresult ;
79804   int result;
79805
79806   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79807   jresult = (int)result;
79808   return jresult;
79809 }
79810
79811
79812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79813   int jresult ;
79814   int result;
79815
79816   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79817   jresult = (int)result;
79818   return jresult;
79819 }
79820
79821
79822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79823   int jresult ;
79824   int result;
79825
79826   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79827   jresult = (int)result;
79828   return jresult;
79829 }
79830
79831
79832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79833   void * jresult ;
79834   Dali::Toolkit::ScrollView::Property *result = 0 ;
79835
79836   {
79837     try {
79838       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79839     } catch (std::out_of_range& e) {
79840       {
79841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79842       };
79843     } catch (std::exception& e) {
79844       {
79845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79846       };
79847     } catch (Dali::DaliException e) {
79848       {
79849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79850       };
79851     } catch (...) {
79852       {
79853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79854       };
79855     }
79856   }
79857
79858   jresult = (void *)result;
79859   return jresult;
79860 }
79861
79862
79863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79864   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79865
79866   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79867   {
79868     try {
79869       delete arg1;
79870     } catch (std::out_of_range& e) {
79871       {
79872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79873       };
79874     } catch (std::exception& e) {
79875       {
79876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79877       };
79878     } catch (Dali::DaliException e) {
79879       {
79880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79881       };
79882     } catch (...) {
79883       {
79884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79885       };
79886     }
79887   }
79888
79889 }
79890
79891
79892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79893   void * jresult ;
79894   Dali::Toolkit::ScrollView *result = 0 ;
79895
79896   {
79897     try {
79898       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79899     } catch (std::out_of_range& e) {
79900       {
79901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79902       };
79903     } catch (std::exception& e) {
79904       {
79905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79906       };
79907     } catch (Dali::DaliException e) {
79908       {
79909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79910       };
79911     } catch (...) {
79912       {
79913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79914       };
79915     }
79916   }
79917
79918   jresult = (void *)result;
79919   return jresult;
79920 }
79921
79922
79923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79924   void * jresult ;
79925   Dali::Toolkit::ScrollView *arg1 = 0 ;
79926   Dali::Toolkit::ScrollView *result = 0 ;
79927
79928   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79929   if (!arg1) {
79930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79931     return 0;
79932   }
79933   {
79934     try {
79935       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79936     } catch (std::out_of_range& e) {
79937       {
79938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79939       };
79940     } catch (std::exception& e) {
79941       {
79942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79943       };
79944     } catch (Dali::DaliException e) {
79945       {
79946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79947       };
79948     } catch (...) {
79949       {
79950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79951       };
79952     }
79953   }
79954
79955   jresult = (void *)result;
79956   return jresult;
79957 }
79958
79959
79960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79961   void * jresult ;
79962   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79963   Dali::Toolkit::ScrollView *arg2 = 0 ;
79964   Dali::Toolkit::ScrollView *result = 0 ;
79965
79966   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79967   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79968   if (!arg2) {
79969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79970     return 0;
79971   }
79972   {
79973     try {
79974       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79975     } catch (std::out_of_range& e) {
79976       {
79977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79978       };
79979     } catch (std::exception& e) {
79980       {
79981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79982       };
79983     } catch (Dali::DaliException e) {
79984       {
79985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79986       };
79987     } catch (...) {
79988       {
79989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79990       };
79991     }
79992   }
79993
79994   jresult = (void *)result;
79995   return jresult;
79996 }
79997
79998
79999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80000   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80001
80002   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80003   {
80004     try {
80005       delete arg1;
80006     } catch (std::out_of_range& e) {
80007       {
80008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80009       };
80010     } catch (std::exception& e) {
80011       {
80012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80013       };
80014     } catch (Dali::DaliException e) {
80015       {
80016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80017       };
80018     } catch (...) {
80019       {
80020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80021       };
80022     }
80023   }
80024
80025 }
80026
80027
80028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80029   void * jresult ;
80030   Dali::Toolkit::ScrollView result;
80031
80032   {
80033     try {
80034       result = Dali::Toolkit::ScrollView::New();
80035     } catch (std::out_of_range& e) {
80036       {
80037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80038       };
80039     } catch (std::exception& e) {
80040       {
80041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80042       };
80043     } catch (Dali::DaliException e) {
80044       {
80045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80046       };
80047     } catch (...) {
80048       {
80049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80050       };
80051     }
80052   }
80053
80054   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80055   return jresult;
80056 }
80057
80058
80059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80060   void * jresult ;
80061   Dali::BaseHandle arg1 ;
80062   Dali::BaseHandle *argp1 ;
80063   Dali::Toolkit::ScrollView result;
80064
80065   argp1 = (Dali::BaseHandle *)jarg1;
80066   if (!argp1) {
80067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80068     return 0;
80069   }
80070   arg1 = *argp1;
80071   {
80072     try {
80073       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80074     } catch (std::out_of_range& e) {
80075       {
80076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80077       };
80078     } catch (std::exception& e) {
80079       {
80080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80081       };
80082     } catch (Dali::DaliException e) {
80083       {
80084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80085       };
80086     } catch (...) {
80087       {
80088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80089       };
80090     }
80091   }
80092
80093   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80094   return jresult;
80095 }
80096
80097
80098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80099   void * jresult ;
80100   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80101   Dali::AlphaFunction result;
80102
80103   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80104   {
80105     try {
80106       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80107     } catch (std::out_of_range& e) {
80108       {
80109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80110       };
80111     } catch (std::exception& e) {
80112       {
80113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80114       };
80115     } catch (Dali::DaliException e) {
80116       {
80117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80118       };
80119     } catch (...) {
80120       {
80121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80122       };
80123     }
80124   }
80125
80126   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80127   return jresult;
80128 }
80129
80130
80131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80132   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80133   Dali::AlphaFunction arg2 ;
80134   Dali::AlphaFunction *argp2 ;
80135
80136   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80137   argp2 = (Dali::AlphaFunction *)jarg2;
80138   if (!argp2) {
80139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80140     return ;
80141   }
80142   arg2 = *argp2;
80143   {
80144     try {
80145       (arg1)->SetScrollSnapAlphaFunction(arg2);
80146     } catch (std::out_of_range& e) {
80147       {
80148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80149       };
80150     } catch (std::exception& e) {
80151       {
80152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80153       };
80154     } catch (Dali::DaliException e) {
80155       {
80156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80157       };
80158     } catch (...) {
80159       {
80160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80161       };
80162     }
80163   }
80164
80165 }
80166
80167
80168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80169   void * jresult ;
80170   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80171   Dali::AlphaFunction result;
80172
80173   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80174   {
80175     try {
80176       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80177     } catch (std::out_of_range& e) {
80178       {
80179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80180       };
80181     } catch (std::exception& e) {
80182       {
80183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80184       };
80185     } catch (Dali::DaliException e) {
80186       {
80187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80188       };
80189     } catch (...) {
80190       {
80191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80192       };
80193     }
80194   }
80195
80196   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80197   return jresult;
80198 }
80199
80200
80201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80202   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80203   Dali::AlphaFunction arg2 ;
80204   Dali::AlphaFunction *argp2 ;
80205
80206   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80207   argp2 = (Dali::AlphaFunction *)jarg2;
80208   if (!argp2) {
80209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80210     return ;
80211   }
80212   arg2 = *argp2;
80213   {
80214     try {
80215       (arg1)->SetScrollFlickAlphaFunction(arg2);
80216     } catch (std::out_of_range& e) {
80217       {
80218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80219       };
80220     } catch (std::exception& e) {
80221       {
80222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80223       };
80224     } catch (Dali::DaliException e) {
80225       {
80226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80227       };
80228     } catch (...) {
80229       {
80230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80231       };
80232     }
80233   }
80234
80235 }
80236
80237
80238 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80239   float jresult ;
80240   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80241   float result;
80242
80243   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80244   {
80245     try {
80246       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80247     } catch (std::out_of_range& e) {
80248       {
80249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80250       };
80251     } catch (std::exception& e) {
80252       {
80253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80254       };
80255     } catch (Dali::DaliException e) {
80256       {
80257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80258       };
80259     } catch (...) {
80260       {
80261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80262       };
80263     }
80264   }
80265
80266   jresult = result;
80267   return jresult;
80268 }
80269
80270
80271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80272   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80273   float arg2 ;
80274
80275   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80276   arg2 = (float)jarg2;
80277   {
80278     try {
80279       (arg1)->SetScrollSnapDuration(arg2);
80280     } catch (std::out_of_range& e) {
80281       {
80282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80283       };
80284     } catch (std::exception& e) {
80285       {
80286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80287       };
80288     } catch (Dali::DaliException e) {
80289       {
80290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80291       };
80292     } catch (...) {
80293       {
80294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80295       };
80296     }
80297   }
80298
80299 }
80300
80301
80302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80303   float jresult ;
80304   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80305   float result;
80306
80307   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80308   {
80309     try {
80310       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80311     } catch (std::out_of_range& e) {
80312       {
80313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80314       };
80315     } catch (std::exception& e) {
80316       {
80317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80318       };
80319     } catch (Dali::DaliException e) {
80320       {
80321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80322       };
80323     } catch (...) {
80324       {
80325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80326       };
80327     }
80328   }
80329
80330   jresult = result;
80331   return jresult;
80332 }
80333
80334
80335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80336   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80337   float arg2 ;
80338
80339   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80340   arg2 = (float)jarg2;
80341   {
80342     try {
80343       (arg1)->SetScrollFlickDuration(arg2);
80344     } catch (std::out_of_range& e) {
80345       {
80346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80347       };
80348     } catch (std::exception& e) {
80349       {
80350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80351       };
80352     } catch (Dali::DaliException e) {
80353       {
80354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80355       };
80356     } catch (...) {
80357       {
80358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80359       };
80360     }
80361   }
80362
80363 }
80364
80365
80366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80367   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80368   Dali::Toolkit::RulerPtr arg2 ;
80369   Dali::Toolkit::RulerPtr *argp2 ;
80370
80371   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80372   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80373   if (!argp2) {
80374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80375     return ;
80376   }
80377   arg2 = *argp2;
80378   {
80379     try {
80380       (arg1)->SetRulerX(arg2);
80381     } catch (std::out_of_range& e) {
80382       {
80383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80384       };
80385     } catch (std::exception& e) {
80386       {
80387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80388       };
80389     } catch (Dali::DaliException e) {
80390       {
80391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80392       };
80393     } catch (...) {
80394       {
80395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80396       };
80397     }
80398   }
80399
80400 }
80401
80402
80403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80404   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80405   Dali::Toolkit::RulerPtr arg2 ;
80406   Dali::Toolkit::RulerPtr *argp2 ;
80407
80408   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80409   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80410   if (!argp2) {
80411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80412     return ;
80413   }
80414   arg2 = *argp2;
80415   {
80416     try {
80417       (arg1)->SetRulerY(arg2);
80418     } catch (std::out_of_range& e) {
80419       {
80420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80421       };
80422     } catch (std::exception& e) {
80423       {
80424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80425       };
80426     } catch (Dali::DaliException e) {
80427       {
80428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80429       };
80430     } catch (...) {
80431       {
80432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80433       };
80434     }
80435   }
80436
80437 }
80438
80439
80440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80441   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80442   bool arg2 ;
80443
80444   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80445   arg2 = jarg2 ? true : false;
80446   {
80447     try {
80448       (arg1)->SetScrollSensitive(arg2);
80449     } catch (std::out_of_range& e) {
80450       {
80451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80452       };
80453     } catch (std::exception& e) {
80454       {
80455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80456       };
80457     } catch (Dali::DaliException e) {
80458       {
80459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80460       };
80461     } catch (...) {
80462       {
80463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80464       };
80465     }
80466   }
80467
80468 }
80469
80470
80471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80472   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80473   float arg2 ;
80474   float arg3 ;
80475
80476   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80477   arg2 = (float)jarg2;
80478   arg3 = (float)jarg3;
80479   {
80480     try {
80481       (arg1)->SetMaxOvershoot(arg2,arg3);
80482     } catch (std::out_of_range& e) {
80483       {
80484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80485       };
80486     } catch (std::exception& e) {
80487       {
80488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80489       };
80490     } catch (Dali::DaliException e) {
80491       {
80492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80493       };
80494     } catch (...) {
80495       {
80496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80497       };
80498     }
80499   }
80500
80501 }
80502
80503
80504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80505   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80506   Dali::AlphaFunction arg2 ;
80507   Dali::AlphaFunction *argp2 ;
80508
80509   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80510   argp2 = (Dali::AlphaFunction *)jarg2;
80511   if (!argp2) {
80512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80513     return ;
80514   }
80515   arg2 = *argp2;
80516   {
80517     try {
80518       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80519     } catch (std::out_of_range& e) {
80520       {
80521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80522       };
80523     } catch (std::exception& e) {
80524       {
80525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80526       };
80527     } catch (Dali::DaliException e) {
80528       {
80529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80530       };
80531     } catch (...) {
80532       {
80533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80534       };
80535     }
80536   }
80537
80538 }
80539
80540
80541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80542   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80543   float arg2 ;
80544
80545   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80546   arg2 = (float)jarg2;
80547   {
80548     try {
80549       (arg1)->SetSnapOvershootDuration(arg2);
80550     } catch (std::out_of_range& e) {
80551       {
80552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80553       };
80554     } catch (std::exception& e) {
80555       {
80556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80557       };
80558     } catch (Dali::DaliException e) {
80559       {
80560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80561       };
80562     } catch (...) {
80563       {
80564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80565       };
80566     }
80567   }
80568
80569 }
80570
80571
80572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80573   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80574   bool arg2 ;
80575
80576   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80577   arg2 = jarg2 ? true : false;
80578   {
80579     try {
80580       (arg1)->SetActorAutoSnap(arg2);
80581     } catch (std::out_of_range& e) {
80582       {
80583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80584       };
80585     } catch (std::exception& e) {
80586       {
80587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80588       };
80589     } catch (Dali::DaliException e) {
80590       {
80591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80592       };
80593     } catch (...) {
80594       {
80595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80596       };
80597     }
80598   }
80599
80600 }
80601
80602
80603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80604   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80605   bool arg2 ;
80606
80607   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80608   arg2 = jarg2 ? true : false;
80609   {
80610     try {
80611       (arg1)->SetWrapMode(arg2);
80612     } catch (std::out_of_range& e) {
80613       {
80614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80615       };
80616     } catch (std::exception& e) {
80617       {
80618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80619       };
80620     } catch (Dali::DaliException e) {
80621       {
80622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80623       };
80624     } catch (...) {
80625       {
80626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80627       };
80628     }
80629   }
80630
80631 }
80632
80633
80634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80635   int jresult ;
80636   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80637   int result;
80638
80639   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80640   {
80641     try {
80642       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80643     } catch (std::out_of_range& e) {
80644       {
80645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80646       };
80647     } catch (std::exception& e) {
80648       {
80649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80650       };
80651     } catch (Dali::DaliException e) {
80652       {
80653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80654       };
80655     } catch (...) {
80656       {
80657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80658       };
80659     }
80660   }
80661
80662   jresult = result;
80663   return jresult;
80664 }
80665
80666
80667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80668   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80669   int arg2 ;
80670
80671   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80672   arg2 = (int)jarg2;
80673   {
80674     try {
80675       (arg1)->SetScrollUpdateDistance(arg2);
80676     } catch (std::out_of_range& e) {
80677       {
80678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80679       };
80680     } catch (std::exception& e) {
80681       {
80682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80683       };
80684     } catch (Dali::DaliException e) {
80685       {
80686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80687       };
80688     } catch (...) {
80689       {
80690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80691       };
80692     }
80693   }
80694
80695 }
80696
80697
80698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80699   unsigned int jresult ;
80700   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80701   bool result;
80702
80703   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80704   {
80705     try {
80706       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80707     } catch (std::out_of_range& e) {
80708       {
80709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80710       };
80711     } catch (std::exception& e) {
80712       {
80713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80714       };
80715     } catch (Dali::DaliException e) {
80716       {
80717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80718       };
80719     } catch (...) {
80720       {
80721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80722       };
80723     }
80724   }
80725
80726   jresult = result;
80727   return jresult;
80728 }
80729
80730
80731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80732   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80733   bool arg2 ;
80734
80735   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80736   arg2 = jarg2 ? true : false;
80737   {
80738     try {
80739       (arg1)->SetAxisAutoLock(arg2);
80740     } catch (std::out_of_range& e) {
80741       {
80742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80743       };
80744     } catch (std::exception& e) {
80745       {
80746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80747       };
80748     } catch (Dali::DaliException e) {
80749       {
80750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80751       };
80752     } catch (...) {
80753       {
80754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80755       };
80756     }
80757   }
80758
80759 }
80760
80761
80762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80763   float jresult ;
80764   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80765   float result;
80766
80767   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80768   {
80769     try {
80770       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80771     } catch (std::out_of_range& e) {
80772       {
80773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80774       };
80775     } catch (std::exception& e) {
80776       {
80777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80778       };
80779     } catch (Dali::DaliException e) {
80780       {
80781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80782       };
80783     } catch (...) {
80784       {
80785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80786       };
80787     }
80788   }
80789
80790   jresult = result;
80791   return jresult;
80792 }
80793
80794
80795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80796   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80797   float arg2 ;
80798
80799   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80800   arg2 = (float)jarg2;
80801   {
80802     try {
80803       (arg1)->SetAxisAutoLockGradient(arg2);
80804     } catch (std::out_of_range& e) {
80805       {
80806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80807       };
80808     } catch (std::exception& e) {
80809       {
80810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80811       };
80812     } catch (Dali::DaliException e) {
80813       {
80814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80815       };
80816     } catch (...) {
80817       {
80818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80819       };
80820     }
80821   }
80822
80823 }
80824
80825
80826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80827   float jresult ;
80828   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80829   float result;
80830
80831   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80832   {
80833     try {
80834       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80835     } catch (std::out_of_range& e) {
80836       {
80837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80838       };
80839     } catch (std::exception& e) {
80840       {
80841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80842       };
80843     } catch (Dali::DaliException e) {
80844       {
80845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80846       };
80847     } catch (...) {
80848       {
80849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80850       };
80851     }
80852   }
80853
80854   jresult = result;
80855   return jresult;
80856 }
80857
80858
80859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80860   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80861   float arg2 ;
80862
80863   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80864   arg2 = (float)jarg2;
80865   {
80866     try {
80867       (arg1)->SetFrictionCoefficient(arg2);
80868     } catch (std::out_of_range& e) {
80869       {
80870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80871       };
80872     } catch (std::exception& e) {
80873       {
80874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80875       };
80876     } catch (Dali::DaliException e) {
80877       {
80878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80879       };
80880     } catch (...) {
80881       {
80882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80883       };
80884     }
80885   }
80886
80887 }
80888
80889
80890 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80891   float jresult ;
80892   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80893   float result;
80894
80895   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80896   {
80897     try {
80898       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80899     } catch (std::out_of_range& e) {
80900       {
80901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80902       };
80903     } catch (std::exception& e) {
80904       {
80905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80906       };
80907     } catch (Dali::DaliException e) {
80908       {
80909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80910       };
80911     } catch (...) {
80912       {
80913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80914       };
80915     }
80916   }
80917
80918   jresult = result;
80919   return jresult;
80920 }
80921
80922
80923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80924   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80925   float arg2 ;
80926
80927   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80928   arg2 = (float)jarg2;
80929   {
80930     try {
80931       (arg1)->SetFlickSpeedCoefficient(arg2);
80932     } catch (std::out_of_range& e) {
80933       {
80934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80935       };
80936     } catch (std::exception& e) {
80937       {
80938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80939       };
80940     } catch (Dali::DaliException e) {
80941       {
80942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80943       };
80944     } catch (...) {
80945       {
80946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80947       };
80948     }
80949   }
80950
80951 }
80952
80953
80954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80955   void * jresult ;
80956   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80957   Dali::Vector2 result;
80958
80959   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80960   {
80961     try {
80962       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80963     } catch (std::out_of_range& e) {
80964       {
80965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80966       };
80967     } catch (std::exception& e) {
80968       {
80969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80970       };
80971     } catch (Dali::DaliException e) {
80972       {
80973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80974       };
80975     } catch (...) {
80976       {
80977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80978       };
80979     }
80980   }
80981
80982   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80983   return jresult;
80984 }
80985
80986
80987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80988   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80989   Dali::Vector2 *arg2 = 0 ;
80990
80991   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80992   arg2 = (Dali::Vector2 *)jarg2;
80993   if (!arg2) {
80994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80995     return ;
80996   }
80997   {
80998     try {
80999       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81000     } catch (std::out_of_range& e) {
81001       {
81002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81003       };
81004     } catch (std::exception& e) {
81005       {
81006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81007       };
81008     } catch (Dali::DaliException e) {
81009       {
81010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81011       };
81012     } catch (...) {
81013       {
81014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81015       };
81016     }
81017   }
81018
81019 }
81020
81021
81022 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81023   float jresult ;
81024   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81025   float result;
81026
81027   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81028   {
81029     try {
81030       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81031     } catch (std::out_of_range& e) {
81032       {
81033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81034       };
81035     } catch (std::exception& e) {
81036       {
81037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81038       };
81039     } catch (Dali::DaliException e) {
81040       {
81041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81042       };
81043     } catch (...) {
81044       {
81045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81046       };
81047     }
81048   }
81049
81050   jresult = result;
81051   return jresult;
81052 }
81053
81054
81055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81056   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81057   float arg2 ;
81058
81059   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81060   arg2 = (float)jarg2;
81061   {
81062     try {
81063       (arg1)->SetMinimumSpeedForFlick(arg2);
81064     } catch (std::out_of_range& e) {
81065       {
81066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81067       };
81068     } catch (std::exception& e) {
81069       {
81070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81071       };
81072     } catch (Dali::DaliException e) {
81073       {
81074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81075       };
81076     } catch (...) {
81077       {
81078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81079       };
81080     }
81081   }
81082
81083 }
81084
81085
81086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81087   float jresult ;
81088   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81089   float result;
81090
81091   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81092   {
81093     try {
81094       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81095     } catch (std::out_of_range& e) {
81096       {
81097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81098       };
81099     } catch (std::exception& e) {
81100       {
81101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81102       };
81103     } catch (Dali::DaliException e) {
81104       {
81105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81106       };
81107     } catch (...) {
81108       {
81109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81110       };
81111     }
81112   }
81113
81114   jresult = result;
81115   return jresult;
81116 }
81117
81118
81119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81120   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81121   float arg2 ;
81122
81123   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81124   arg2 = (float)jarg2;
81125   {
81126     try {
81127       (arg1)->SetMaxFlickSpeed(arg2);
81128     } catch (std::out_of_range& e) {
81129       {
81130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81131       };
81132     } catch (std::exception& e) {
81133       {
81134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81135       };
81136     } catch (Dali::DaliException e) {
81137       {
81138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81139       };
81140     } catch (...) {
81141       {
81142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81143       };
81144     }
81145   }
81146
81147 }
81148
81149
81150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81151   void * jresult ;
81152   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81153   Dali::Vector2 result;
81154
81155   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81156   {
81157     try {
81158       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81159     } catch (std::out_of_range& e) {
81160       {
81161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81162       };
81163     } catch (std::exception& e) {
81164       {
81165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81166       };
81167     } catch (Dali::DaliException e) {
81168       {
81169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81170       };
81171     } catch (...) {
81172       {
81173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81174       };
81175     }
81176   }
81177
81178   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81179   return jresult;
81180 }
81181
81182
81183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81184   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81185   Dali::Vector2 arg2 ;
81186   Dali::Vector2 *argp2 ;
81187
81188   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81189   argp2 = (Dali::Vector2 *)jarg2;
81190   if (!argp2) {
81191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81192     return ;
81193   }
81194   arg2 = *argp2;
81195   {
81196     try {
81197       (arg1)->SetWheelScrollDistanceStep(arg2);
81198     } catch (std::out_of_range& e) {
81199       {
81200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81201       };
81202     } catch (std::exception& e) {
81203       {
81204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81205       };
81206     } catch (Dali::DaliException e) {
81207       {
81208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81209       };
81210     } catch (...) {
81211       {
81212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81213       };
81214     }
81215   }
81216
81217 }
81218
81219
81220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81221   void * jresult ;
81222   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81223   Dali::Vector2 result;
81224
81225   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81226   {
81227     try {
81228       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81229     } catch (std::out_of_range& e) {
81230       {
81231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81232       };
81233     } catch (std::exception& e) {
81234       {
81235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81236       };
81237     } catch (Dali::DaliException e) {
81238       {
81239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81240       };
81241     } catch (...) {
81242       {
81243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81244       };
81245     }
81246   }
81247
81248   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81249   return jresult;
81250 }
81251
81252
81253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81254   unsigned int jresult ;
81255   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81256   unsigned int result;
81257
81258   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81259   {
81260     try {
81261       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81262     } catch (std::out_of_range& e) {
81263       {
81264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81265       };
81266     } catch (std::exception& e) {
81267       {
81268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81269       };
81270     } catch (Dali::DaliException e) {
81271       {
81272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81273       };
81274     } catch (...) {
81275       {
81276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81277       };
81278     }
81279   }
81280
81281   jresult = result;
81282   return jresult;
81283 }
81284
81285
81286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81287   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81288   Dali::Vector2 *arg2 = 0 ;
81289
81290   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81291   arg2 = (Dali::Vector2 *)jarg2;
81292   if (!arg2) {
81293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81294     return ;
81295   }
81296   {
81297     try {
81298       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81299     } catch (std::out_of_range& e) {
81300       {
81301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81302       };
81303     } catch (std::exception& e) {
81304       {
81305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81306       };
81307     } catch (Dali::DaliException e) {
81308       {
81309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81310       };
81311     } catch (...) {
81312       {
81313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81314       };
81315     }
81316   }
81317
81318 }
81319
81320
81321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81322   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81323   Dali::Vector2 *arg2 = 0 ;
81324   float arg3 ;
81325
81326   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81327   arg2 = (Dali::Vector2 *)jarg2;
81328   if (!arg2) {
81329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81330     return ;
81331   }
81332   arg3 = (float)jarg3;
81333   {
81334     try {
81335       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81336     } catch (std::out_of_range& e) {
81337       {
81338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81339       };
81340     } catch (std::exception& e) {
81341       {
81342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81343       };
81344     } catch (Dali::DaliException e) {
81345       {
81346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81347       };
81348     } catch (...) {
81349       {
81350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81351       };
81352     }
81353   }
81354
81355 }
81356
81357
81358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81359   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81360   Dali::Vector2 *arg2 = 0 ;
81361   float arg3 ;
81362   Dali::AlphaFunction arg4 ;
81363   Dali::AlphaFunction *argp4 ;
81364
81365   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81366   arg2 = (Dali::Vector2 *)jarg2;
81367   if (!arg2) {
81368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81369     return ;
81370   }
81371   arg3 = (float)jarg3;
81372   argp4 = (Dali::AlphaFunction *)jarg4;
81373   if (!argp4) {
81374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81375     return ;
81376   }
81377   arg4 = *argp4;
81378   {
81379     try {
81380       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81381     } catch (std::out_of_range& e) {
81382       {
81383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81384       };
81385     } catch (std::exception& e) {
81386       {
81387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81388       };
81389     } catch (Dali::DaliException e) {
81390       {
81391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81392       };
81393     } catch (...) {
81394       {
81395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81396       };
81397     }
81398   }
81399
81400 }
81401
81402
81403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81404   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81405   Dali::Vector2 *arg2 = 0 ;
81406   float arg3 ;
81407   Dali::Toolkit::DirectionBias arg4 ;
81408   Dali::Toolkit::DirectionBias arg5 ;
81409
81410   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81411   arg2 = (Dali::Vector2 *)jarg2;
81412   if (!arg2) {
81413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81414     return ;
81415   }
81416   arg3 = (float)jarg3;
81417   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81418   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81419   {
81420     try {
81421       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81422     } catch (std::out_of_range& e) {
81423       {
81424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81425       };
81426     } catch (std::exception& e) {
81427       {
81428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81429       };
81430     } catch (Dali::DaliException e) {
81431       {
81432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81433       };
81434     } catch (...) {
81435       {
81436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81437       };
81438     }
81439   }
81440
81441 }
81442
81443
81444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81445   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81446   Dali::Vector2 *arg2 = 0 ;
81447   float arg3 ;
81448   Dali::AlphaFunction arg4 ;
81449   Dali::Toolkit::DirectionBias arg5 ;
81450   Dali::Toolkit::DirectionBias arg6 ;
81451   Dali::AlphaFunction *argp4 ;
81452
81453   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81454   arg2 = (Dali::Vector2 *)jarg2;
81455   if (!arg2) {
81456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81457     return ;
81458   }
81459   arg3 = (float)jarg3;
81460   argp4 = (Dali::AlphaFunction *)jarg4;
81461   if (!argp4) {
81462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81463     return ;
81464   }
81465   arg4 = *argp4;
81466   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81467   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81468   {
81469     try {
81470       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81471     } catch (std::out_of_range& e) {
81472       {
81473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81474       };
81475     } catch (std::exception& e) {
81476       {
81477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81478       };
81479     } catch (Dali::DaliException e) {
81480       {
81481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81482       };
81483     } catch (...) {
81484       {
81485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81486       };
81487     }
81488   }
81489
81490 }
81491
81492
81493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81494   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81495   unsigned int arg2 ;
81496
81497   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81498   arg2 = (unsigned int)jarg2;
81499   {
81500     try {
81501       (arg1)->ScrollTo(arg2);
81502     } catch (std::out_of_range& e) {
81503       {
81504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81505       };
81506     } catch (std::exception& e) {
81507       {
81508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81509       };
81510     } catch (Dali::DaliException e) {
81511       {
81512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81513       };
81514     } catch (...) {
81515       {
81516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81517       };
81518     }
81519   }
81520
81521 }
81522
81523
81524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81525   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81526   unsigned int arg2 ;
81527   float arg3 ;
81528
81529   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81530   arg2 = (unsigned int)jarg2;
81531   arg3 = (float)jarg3;
81532   {
81533     try {
81534       (arg1)->ScrollTo(arg2,arg3);
81535     } catch (std::out_of_range& e) {
81536       {
81537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81538       };
81539     } catch (std::exception& e) {
81540       {
81541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81542       };
81543     } catch (Dali::DaliException e) {
81544       {
81545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81546       };
81547     } catch (...) {
81548       {
81549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81550       };
81551     }
81552   }
81553
81554 }
81555
81556
81557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81558   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81559   unsigned int arg2 ;
81560   float arg3 ;
81561   Dali::Toolkit::DirectionBias arg4 ;
81562
81563   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81564   arg2 = (unsigned int)jarg2;
81565   arg3 = (float)jarg3;
81566   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81567   {
81568     try {
81569       (arg1)->ScrollTo(arg2,arg3,arg4);
81570     } catch (std::out_of_range& e) {
81571       {
81572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81573       };
81574     } catch (std::exception& e) {
81575       {
81576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81577       };
81578     } catch (Dali::DaliException e) {
81579       {
81580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81581       };
81582     } catch (...) {
81583       {
81584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81585       };
81586     }
81587   }
81588
81589 }
81590
81591
81592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81593   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81594   Dali::Actor *arg2 = 0 ;
81595
81596   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81597   arg2 = (Dali::Actor *)jarg2;
81598   if (!arg2) {
81599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81600     return ;
81601   }
81602   {
81603     try {
81604       (arg1)->ScrollTo(*arg2);
81605     } catch (std::out_of_range& e) {
81606       {
81607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81608       };
81609     } catch (std::exception& e) {
81610       {
81611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81612       };
81613     } catch (Dali::DaliException e) {
81614       {
81615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81616       };
81617     } catch (...) {
81618       {
81619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81620       };
81621     }
81622   }
81623
81624 }
81625
81626
81627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81628   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81629   Dali::Actor *arg2 = 0 ;
81630   float arg3 ;
81631
81632   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81633   arg2 = (Dali::Actor *)jarg2;
81634   if (!arg2) {
81635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81636     return ;
81637   }
81638   arg3 = (float)jarg3;
81639   {
81640     try {
81641       (arg1)->ScrollTo(*arg2,arg3);
81642     } catch (std::out_of_range& e) {
81643       {
81644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81645       };
81646     } catch (std::exception& e) {
81647       {
81648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81649       };
81650     } catch (Dali::DaliException e) {
81651       {
81652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81653       };
81654     } catch (...) {
81655       {
81656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81657       };
81658     }
81659   }
81660
81661 }
81662
81663
81664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81665   unsigned int jresult ;
81666   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81667   bool result;
81668
81669   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81670   {
81671     try {
81672       result = (bool)(arg1)->ScrollToSnapPoint();
81673     } catch (std::out_of_range& e) {
81674       {
81675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81676       };
81677     } catch (std::exception& e) {
81678       {
81679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81680       };
81681     } catch (Dali::DaliException e) {
81682       {
81683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81684       };
81685     } catch (...) {
81686       {
81687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81688       };
81689     }
81690   }
81691
81692   jresult = result;
81693   return jresult;
81694 }
81695
81696
81697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81698   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81699   Dali::Constraint arg2 ;
81700   Dali::Constraint *argp2 ;
81701
81702   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81703   argp2 = (Dali::Constraint *)jarg2;
81704   if (!argp2) {
81705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81706     return ;
81707   }
81708   arg2 = *argp2;
81709   {
81710     try {
81711       (arg1)->ApplyConstraintToChildren(arg2);
81712     } catch (std::out_of_range& e) {
81713       {
81714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81715       };
81716     } catch (std::exception& e) {
81717       {
81718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81719       };
81720     } catch (Dali::DaliException e) {
81721       {
81722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81723       };
81724     } catch (...) {
81725       {
81726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81727       };
81728     }
81729   }
81730
81731 }
81732
81733
81734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81735   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81736
81737   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81738   {
81739     try {
81740       (arg1)->RemoveConstraintsFromChildren();
81741     } catch (std::out_of_range& e) {
81742       {
81743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81744       };
81745     } catch (std::exception& e) {
81746       {
81747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81748       };
81749     } catch (Dali::DaliException e) {
81750       {
81751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81752       };
81753     } catch (...) {
81754       {
81755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81756       };
81757     }
81758   }
81759
81760 }
81761
81762
81763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81764   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81765   Dali::Toolkit::ScrollViewEffect arg2 ;
81766   Dali::Toolkit::ScrollViewEffect *argp2 ;
81767
81768   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81769   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81770   if (!argp2) {
81771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81772     return ;
81773   }
81774   arg2 = *argp2;
81775   {
81776     try {
81777       (arg1)->ApplyEffect(arg2);
81778     } catch (std::out_of_range& e) {
81779       {
81780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81781       };
81782     } catch (std::exception& e) {
81783       {
81784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81785       };
81786     } catch (Dali::DaliException e) {
81787       {
81788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81789       };
81790     } catch (...) {
81791       {
81792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81793       };
81794     }
81795   }
81796
81797 }
81798
81799
81800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81801   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81802   Dali::Toolkit::ScrollViewEffect arg2 ;
81803   Dali::Toolkit::ScrollViewEffect *argp2 ;
81804
81805   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81806   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81807   if (!argp2) {
81808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81809     return ;
81810   }
81811   arg2 = *argp2;
81812   {
81813     try {
81814       (arg1)->RemoveEffect(arg2);
81815     } catch (std::out_of_range& e) {
81816       {
81817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81818       };
81819     } catch (std::exception& e) {
81820       {
81821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81822       };
81823     } catch (Dali::DaliException e) {
81824       {
81825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81826       };
81827     } catch (...) {
81828       {
81829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81830       };
81831     }
81832   }
81833
81834 }
81835
81836
81837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81838   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81839
81840   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81841   {
81842     try {
81843       (arg1)->RemoveAllEffects();
81844     } catch (std::out_of_range& e) {
81845       {
81846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81847       };
81848     } catch (std::exception& e) {
81849       {
81850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81851       };
81852     } catch (Dali::DaliException e) {
81853       {
81854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81855       };
81856     } catch (...) {
81857       {
81858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81859       };
81860     }
81861   }
81862
81863 }
81864
81865
81866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81867   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81868   Dali::Actor arg2 ;
81869   Dali::Actor *argp2 ;
81870
81871   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81872   argp2 = (Dali::Actor *)jarg2;
81873   if (!argp2) {
81874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81875     return ;
81876   }
81877   arg2 = *argp2;
81878   {
81879     try {
81880       (arg1)->BindActor(arg2);
81881     } catch (std::out_of_range& e) {
81882       {
81883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81884       };
81885     } catch (std::exception& e) {
81886       {
81887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81888       };
81889     } catch (Dali::DaliException e) {
81890       {
81891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81892       };
81893     } catch (...) {
81894       {
81895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81896       };
81897     }
81898   }
81899
81900 }
81901
81902
81903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81904   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81905   Dali::Actor arg2 ;
81906   Dali::Actor *argp2 ;
81907
81908   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81909   argp2 = (Dali::Actor *)jarg2;
81910   if (!argp2) {
81911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81912     return ;
81913   }
81914   arg2 = *argp2;
81915   {
81916     try {
81917       (arg1)->UnbindActor(arg2);
81918     } catch (std::out_of_range& e) {
81919       {
81920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81921       };
81922     } catch (std::exception& e) {
81923       {
81924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81925       };
81926     } catch (Dali::DaliException e) {
81927       {
81928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81929       };
81930     } catch (...) {
81931       {
81932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81933       };
81934     }
81935   }
81936
81937 }
81938
81939
81940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81941   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81942   Dali::Radian arg2 ;
81943   Dali::Radian arg3 ;
81944   Dali::Radian *argp2 ;
81945   Dali::Radian *argp3 ;
81946
81947   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81948   argp2 = (Dali::Radian *)jarg2;
81949   if (!argp2) {
81950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81951     return ;
81952   }
81953   arg2 = *argp2;
81954   argp3 = (Dali::Radian *)jarg3;
81955   if (!argp3) {
81956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81957     return ;
81958   }
81959   arg3 = *argp3;
81960   {
81961     try {
81962       (arg1)->SetScrollingDirection(arg2,arg3);
81963     } catch (std::out_of_range& e) {
81964       {
81965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81966       };
81967     } catch (std::exception& e) {
81968       {
81969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81970       };
81971     } catch (Dali::DaliException e) {
81972       {
81973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81974       };
81975     } catch (...) {
81976       {
81977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81978       };
81979     }
81980   }
81981
81982 }
81983
81984
81985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81986   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81987   Dali::Radian arg2 ;
81988   Dali::Radian *argp2 ;
81989
81990   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81991   argp2 = (Dali::Radian *)jarg2;
81992   if (!argp2) {
81993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81994     return ;
81995   }
81996   arg2 = *argp2;
81997   {
81998     try {
81999       (arg1)->SetScrollingDirection(arg2);
82000     } catch (std::out_of_range& e) {
82001       {
82002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82003       };
82004     } catch (std::exception& e) {
82005       {
82006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82007       };
82008     } catch (Dali::DaliException e) {
82009       {
82010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82011       };
82012     } catch (...) {
82013       {
82014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82015       };
82016     }
82017   }
82018
82019 }
82020
82021
82022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82023   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82024   Dali::Radian arg2 ;
82025   Dali::Radian *argp2 ;
82026
82027   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82028   argp2 = (Dali::Radian *)jarg2;
82029   if (!argp2) {
82030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82031     return ;
82032   }
82033   arg2 = *argp2;
82034   {
82035     try {
82036       (arg1)->RemoveScrollingDirection(arg2);
82037     } catch (std::out_of_range& e) {
82038       {
82039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82040       };
82041     } catch (std::exception& e) {
82042       {
82043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82044       };
82045     } catch (Dali::DaliException e) {
82046       {
82047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82048       };
82049     } catch (...) {
82050       {
82051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82052       };
82053     }
82054   }
82055
82056 }
82057
82058
82059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82060   void * jresult ;
82061   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82062   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82063
82064   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82065   {
82066     try {
82067       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82068     } catch (std::out_of_range& e) {
82069       {
82070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82071       };
82072     } catch (std::exception& e) {
82073       {
82074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82075       };
82076     } catch (Dali::DaliException e) {
82077       {
82078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82079       };
82080     } catch (...) {
82081       {
82082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82083       };
82084     }
82085   }
82086
82087   jresult = (void *)result;
82088   return jresult;
82089 }
82090
82091
82092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82093   int jresult ;
82094   int result;
82095
82096   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82097   jresult = (int)result;
82098   return jresult;
82099 }
82100
82101
82102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82103   int jresult ;
82104   int result;
82105
82106   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82107   jresult = (int)result;
82108   return jresult;
82109 }
82110
82111
82112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82113   int jresult ;
82114   int result;
82115
82116   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82117   jresult = (int)result;
82118   return jresult;
82119 }
82120
82121
82122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82123   int jresult ;
82124   int result;
82125
82126   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82127   jresult = (int)result;
82128   return jresult;
82129 }
82130
82131
82132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82133   int jresult ;
82134   int result;
82135
82136   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82137   jresult = (int)result;
82138   return jresult;
82139 }
82140
82141
82142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82143   void * jresult ;
82144   Dali::Toolkit::TableView::Property *result = 0 ;
82145
82146   {
82147     try {
82148       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82149     } catch (std::out_of_range& e) {
82150       {
82151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82152       };
82153     } catch (std::exception& e) {
82154       {
82155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82156       };
82157     } catch (Dali::DaliException e) {
82158       {
82159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82160       };
82161     } catch (...) {
82162       {
82163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82164       };
82165     }
82166   }
82167
82168   jresult = (void *)result;
82169   return jresult;
82170 }
82171
82172
82173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82174   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82175
82176   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82177   {
82178     try {
82179       delete arg1;
82180     } catch (std::out_of_range& e) {
82181       {
82182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82183       };
82184     } catch (std::exception& e) {
82185       {
82186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82187       };
82188     } catch (Dali::DaliException e) {
82189       {
82190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82191       };
82192     } catch (...) {
82193       {
82194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82195       };
82196     }
82197   }
82198
82199 }
82200
82201
82202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82203   int jresult ;
82204   int result;
82205
82206   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82207   jresult = (int)result;
82208   return jresult;
82209 }
82210
82211
82212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82213   int jresult ;
82214   int result;
82215
82216   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82217   jresult = (int)result;
82218   return jresult;
82219 }
82220
82221
82222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82223   int jresult ;
82224   int result;
82225
82226   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82227   jresult = (int)result;
82228   return jresult;
82229 }
82230
82231
82232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82233   int jresult ;
82234   int result;
82235
82236   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82237   jresult = (int)result;
82238   return jresult;
82239 }
82240
82241
82242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82243   int jresult ;
82244   int result;
82245
82246   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82247   jresult = (int)result;
82248   return jresult;
82249 }
82250
82251
82252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82253   void * jresult ;
82254   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82255
82256   {
82257     try {
82258       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82259     } catch (std::out_of_range& e) {
82260       {
82261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82262       };
82263     } catch (std::exception& e) {
82264       {
82265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82266       };
82267     } catch (Dali::DaliException e) {
82268       {
82269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82270       };
82271     } catch (...) {
82272       {
82273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82274       };
82275     }
82276   }
82277
82278   jresult = (void *)result;
82279   return jresult;
82280 }
82281
82282
82283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82284   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82285
82286   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82287   {
82288     try {
82289       delete arg1;
82290     } catch (std::out_of_range& e) {
82291       {
82292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82293       };
82294     } catch (std::exception& e) {
82295       {
82296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82297       };
82298     } catch (Dali::DaliException e) {
82299       {
82300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82301       };
82302     } catch (...) {
82303       {
82304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82305       };
82306     }
82307   }
82308
82309 }
82310
82311
82312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82313   void * jresult ;
82314   unsigned int arg1 ;
82315   unsigned int arg2 ;
82316   unsigned int arg3 ;
82317   unsigned int arg4 ;
82318   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82319
82320   arg1 = (unsigned int)jarg1;
82321   arg2 = (unsigned int)jarg2;
82322   arg3 = (unsigned int)jarg3;
82323   arg4 = (unsigned int)jarg4;
82324   {
82325     try {
82326       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82327     } catch (std::out_of_range& e) {
82328       {
82329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82330       };
82331     } catch (std::exception& e) {
82332       {
82333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82334       };
82335     } catch (Dali::DaliException e) {
82336       {
82337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82338       };
82339     } catch (...) {
82340       {
82341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82342       };
82343     }
82344   }
82345
82346   jresult = (void *)result;
82347   return jresult;
82348 }
82349
82350
82351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82352   void * jresult ;
82353   unsigned int arg1 ;
82354   unsigned int arg2 ;
82355   unsigned int arg3 ;
82356   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82357
82358   arg1 = (unsigned int)jarg1;
82359   arg2 = (unsigned int)jarg2;
82360   arg3 = (unsigned int)jarg3;
82361   {
82362     try {
82363       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82364     } catch (std::out_of_range& e) {
82365       {
82366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82367       };
82368     } catch (std::exception& e) {
82369       {
82370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82371       };
82372     } catch (Dali::DaliException e) {
82373       {
82374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82375       };
82376     } catch (...) {
82377       {
82378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82379       };
82380     }
82381   }
82382
82383   jresult = (void *)result;
82384   return jresult;
82385 }
82386
82387
82388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82389   void * jresult ;
82390   unsigned int arg1 ;
82391   unsigned int arg2 ;
82392   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82393
82394   arg1 = (unsigned int)jarg1;
82395   arg2 = (unsigned int)jarg2;
82396   {
82397     try {
82398       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82399     } catch (std::out_of_range& e) {
82400       {
82401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82402       };
82403     } catch (std::exception& e) {
82404       {
82405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82406       };
82407     } catch (Dali::DaliException e) {
82408       {
82409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82410       };
82411     } catch (...) {
82412       {
82413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82414       };
82415     }
82416   }
82417
82418   jresult = (void *)result;
82419   return jresult;
82420 }
82421
82422
82423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82424   void * jresult ;
82425   unsigned int arg1 ;
82426   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82427
82428   arg1 = (unsigned int)jarg1;
82429   {
82430     try {
82431       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82432     } catch (std::out_of_range& e) {
82433       {
82434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82435       };
82436     } catch (std::exception& e) {
82437       {
82438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82439       };
82440     } catch (Dali::DaliException e) {
82441       {
82442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82443       };
82444     } catch (...) {
82445       {
82446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82447       };
82448     }
82449   }
82450
82451   jresult = (void *)result;
82452   return jresult;
82453 }
82454
82455
82456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82457   void * jresult ;
82458   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82459
82460   {
82461     try {
82462       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82463     } catch (std::out_of_range& e) {
82464       {
82465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82466       };
82467     } catch (std::exception& e) {
82468       {
82469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82470       };
82471     } catch (Dali::DaliException e) {
82472       {
82473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82474       };
82475     } catch (...) {
82476       {
82477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82478       };
82479     }
82480   }
82481
82482   jresult = (void *)result;
82483   return jresult;
82484 }
82485
82486
82487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82488   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82489   unsigned int arg2 ;
82490
82491   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82492   arg2 = (unsigned int)jarg2;
82493   if (arg1) (arg1)->rowIndex = arg2;
82494 }
82495
82496
82497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82498   unsigned int jresult ;
82499   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82500   unsigned int result;
82501
82502   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82503   result = (unsigned int) ((arg1)->rowIndex);
82504   jresult = result;
82505   return jresult;
82506 }
82507
82508
82509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82510   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82511   unsigned int arg2 ;
82512
82513   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82514   arg2 = (unsigned int)jarg2;
82515   if (arg1) (arg1)->columnIndex = arg2;
82516 }
82517
82518
82519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82520   unsigned int jresult ;
82521   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82522   unsigned int result;
82523
82524   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82525   result = (unsigned int) ((arg1)->columnIndex);
82526   jresult = result;
82527   return jresult;
82528 }
82529
82530
82531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82532   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82533   unsigned int arg2 ;
82534
82535   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82536   arg2 = (unsigned int)jarg2;
82537   if (arg1) (arg1)->rowSpan = arg2;
82538 }
82539
82540
82541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82542   unsigned int jresult ;
82543   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82544   unsigned int result;
82545
82546   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82547   result = (unsigned int) ((arg1)->rowSpan);
82548   jresult = result;
82549   return jresult;
82550 }
82551
82552
82553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82554   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82555   unsigned int arg2 ;
82556
82557   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82558   arg2 = (unsigned int)jarg2;
82559   if (arg1) (arg1)->columnSpan = arg2;
82560 }
82561
82562
82563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82564   unsigned int jresult ;
82565   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82566   unsigned int result;
82567
82568   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82569   result = (unsigned int) ((arg1)->columnSpan);
82570   jresult = result;
82571   return jresult;
82572 }
82573
82574
82575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82576   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82577
82578   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82579   {
82580     try {
82581       delete arg1;
82582     } catch (std::out_of_range& e) {
82583       {
82584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82585       };
82586     } catch (std::exception& e) {
82587       {
82588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82589       };
82590     } catch (Dali::DaliException e) {
82591       {
82592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82593       };
82594     } catch (...) {
82595       {
82596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82597       };
82598     }
82599   }
82600
82601 }
82602
82603
82604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82605   void * jresult ;
82606   Dali::Toolkit::TableView *result = 0 ;
82607
82608   {
82609     try {
82610       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82611     } catch (std::out_of_range& e) {
82612       {
82613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82614       };
82615     } catch (std::exception& e) {
82616       {
82617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82618       };
82619     } catch (Dali::DaliException e) {
82620       {
82621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82622       };
82623     } catch (...) {
82624       {
82625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82626       };
82627     }
82628   }
82629
82630   jresult = (void *)result;
82631   return jresult;
82632 }
82633
82634
82635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82636   void * jresult ;
82637   Dali::Toolkit::TableView *arg1 = 0 ;
82638   Dali::Toolkit::TableView *result = 0 ;
82639
82640   arg1 = (Dali::Toolkit::TableView *)jarg1;
82641   if (!arg1) {
82642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82643     return 0;
82644   }
82645   {
82646     try {
82647       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82648     } catch (std::out_of_range& e) {
82649       {
82650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82651       };
82652     } catch (std::exception& e) {
82653       {
82654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82655       };
82656     } catch (Dali::DaliException e) {
82657       {
82658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82659       };
82660     } catch (...) {
82661       {
82662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82663       };
82664     }
82665   }
82666
82667   jresult = (void *)result;
82668   return jresult;
82669 }
82670
82671
82672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82673   void * jresult ;
82674   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82675   Dali::Toolkit::TableView *arg2 = 0 ;
82676   Dali::Toolkit::TableView *result = 0 ;
82677
82678   arg1 = (Dali::Toolkit::TableView *)jarg1;
82679   arg2 = (Dali::Toolkit::TableView *)jarg2;
82680   if (!arg2) {
82681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82682     return 0;
82683   }
82684   {
82685     try {
82686       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82687     } catch (std::out_of_range& e) {
82688       {
82689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82690       };
82691     } catch (std::exception& e) {
82692       {
82693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82694       };
82695     } catch (Dali::DaliException e) {
82696       {
82697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82698       };
82699     } catch (...) {
82700       {
82701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82702       };
82703     }
82704   }
82705
82706   jresult = (void *)result;
82707   return jresult;
82708 }
82709
82710
82711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82712   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82713
82714   arg1 = (Dali::Toolkit::TableView *)jarg1;
82715   {
82716     try {
82717       delete arg1;
82718     } catch (std::out_of_range& e) {
82719       {
82720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82721       };
82722     } catch (std::exception& e) {
82723       {
82724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82725       };
82726     } catch (Dali::DaliException e) {
82727       {
82728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82729       };
82730     } catch (...) {
82731       {
82732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82733       };
82734     }
82735   }
82736
82737 }
82738
82739
82740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82741   void * jresult ;
82742   unsigned int arg1 ;
82743   unsigned int arg2 ;
82744   Dali::Toolkit::TableView result;
82745
82746   arg1 = (unsigned int)jarg1;
82747   arg2 = (unsigned int)jarg2;
82748   {
82749     try {
82750       result = Dali::Toolkit::TableView::New(arg1,arg2);
82751     } catch (std::out_of_range& e) {
82752       {
82753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82754       };
82755     } catch (std::exception& e) {
82756       {
82757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82758       };
82759     } catch (Dali::DaliException e) {
82760       {
82761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82762       };
82763     } catch (...) {
82764       {
82765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82766       };
82767     }
82768   }
82769
82770   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82771   return jresult;
82772 }
82773
82774
82775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82776   void * jresult ;
82777   Dali::BaseHandle arg1 ;
82778   Dali::BaseHandle *argp1 ;
82779   Dali::Toolkit::TableView result;
82780
82781   argp1 = (Dali::BaseHandle *)jarg1;
82782   if (!argp1) {
82783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82784     return 0;
82785   }
82786   arg1 = *argp1;
82787   {
82788     try {
82789       result = Dali::Toolkit::TableView::DownCast(arg1);
82790     } catch (std::out_of_range& e) {
82791       {
82792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82793       };
82794     } catch (std::exception& e) {
82795       {
82796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82797       };
82798     } catch (Dali::DaliException e) {
82799       {
82800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82801       };
82802     } catch (...) {
82803       {
82804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82805       };
82806     }
82807   }
82808
82809   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82810   return jresult;
82811 }
82812
82813
82814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82815   unsigned int jresult ;
82816   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82817   Dali::Actor arg2 ;
82818   Dali::Toolkit::TableView::CellPosition arg3 ;
82819   Dali::Actor *argp2 ;
82820   Dali::Toolkit::TableView::CellPosition *argp3 ;
82821   bool result;
82822
82823   arg1 = (Dali::Toolkit::TableView *)jarg1;
82824   argp2 = (Dali::Actor *)jarg2;
82825   if (!argp2) {
82826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82827     return 0;
82828   }
82829   arg2 = *argp2;
82830   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82831   if (!argp3) {
82832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82833     return 0;
82834   }
82835   arg3 = *argp3;
82836   {
82837     try {
82838       result = (bool)(arg1)->AddChild(arg2,arg3);
82839     } catch (std::out_of_range& e) {
82840       {
82841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82842       };
82843     } catch (std::exception& e) {
82844       {
82845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82846       };
82847     } catch (Dali::DaliException e) {
82848       {
82849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82850       };
82851     } catch (...) {
82852       {
82853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82854       };
82855     }
82856   }
82857
82858   jresult = result;
82859   return jresult;
82860 }
82861
82862
82863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82864   void * jresult ;
82865   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82866   Dali::Toolkit::TableView::CellPosition arg2 ;
82867   Dali::Toolkit::TableView::CellPosition *argp2 ;
82868   Dali::Actor result;
82869
82870   arg1 = (Dali::Toolkit::TableView *)jarg1;
82871   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82872   if (!argp2) {
82873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82874     return 0;
82875   }
82876   arg2 = *argp2;
82877   {
82878     try {
82879       result = (arg1)->GetChildAt(arg2);
82880     } catch (std::out_of_range& e) {
82881       {
82882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82883       };
82884     } catch (std::exception& e) {
82885       {
82886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82887       };
82888     } catch (Dali::DaliException e) {
82889       {
82890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82891       };
82892     } catch (...) {
82893       {
82894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82895       };
82896     }
82897   }
82898
82899   jresult = new Dali::Actor((const Dali::Actor &)result);
82900   return jresult;
82901 }
82902
82903
82904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82905   void * jresult ;
82906   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82907   Dali::Toolkit::TableView::CellPosition arg2 ;
82908   Dali::Toolkit::TableView::CellPosition *argp2 ;
82909   Dali::Actor result;
82910
82911   arg1 = (Dali::Toolkit::TableView *)jarg1;
82912   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82913   if (!argp2) {
82914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82915     return 0;
82916   }
82917   arg2 = *argp2;
82918   {
82919     try {
82920       result = (arg1)->RemoveChildAt(arg2);
82921     } catch (std::out_of_range& e) {
82922       {
82923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82924       };
82925     } catch (std::exception& e) {
82926       {
82927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82928       };
82929     } catch (Dali::DaliException e) {
82930       {
82931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82932       };
82933     } catch (...) {
82934       {
82935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82936       };
82937     }
82938   }
82939
82940   jresult = new Dali::Actor((const Dali::Actor &)result);
82941   return jresult;
82942 }
82943
82944
82945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82946   unsigned int jresult ;
82947   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82948   Dali::Actor arg2 ;
82949   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82950   Dali::Actor *argp2 ;
82951   bool result;
82952
82953   arg1 = (Dali::Toolkit::TableView *)jarg1;
82954   argp2 = (Dali::Actor *)jarg2;
82955   if (!argp2) {
82956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82957     return 0;
82958   }
82959   arg2 = *argp2;
82960   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82961   if (!arg3) {
82962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82963     return 0;
82964   }
82965   {
82966     try {
82967       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82968     } catch (std::out_of_range& e) {
82969       {
82970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82971       };
82972     } catch (std::exception& e) {
82973       {
82974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82975       };
82976     } catch (Dali::DaliException e) {
82977       {
82978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82979       };
82980     } catch (...) {
82981       {
82982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82983       };
82984     }
82985   }
82986
82987   jresult = result;
82988   return jresult;
82989 }
82990
82991
82992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82993   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82994   unsigned int arg2 ;
82995
82996   arg1 = (Dali::Toolkit::TableView *)jarg1;
82997   arg2 = (unsigned int)jarg2;
82998   {
82999     try {
83000       (arg1)->InsertRow(arg2);
83001     } catch (std::out_of_range& e) {
83002       {
83003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83004       };
83005     } catch (std::exception& e) {
83006       {
83007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83008       };
83009     } catch (Dali::DaliException e) {
83010       {
83011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83012       };
83013     } catch (...) {
83014       {
83015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83016       };
83017     }
83018   }
83019
83020 }
83021
83022
83023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83024   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83025   unsigned int arg2 ;
83026
83027   arg1 = (Dali::Toolkit::TableView *)jarg1;
83028   arg2 = (unsigned int)jarg2;
83029   {
83030     try {
83031       (arg1)->DeleteRow(arg2);
83032     } catch (std::out_of_range& e) {
83033       {
83034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83035       };
83036     } catch (std::exception& e) {
83037       {
83038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83039       };
83040     } catch (Dali::DaliException e) {
83041       {
83042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83043       };
83044     } catch (...) {
83045       {
83046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83047       };
83048     }
83049   }
83050
83051 }
83052
83053
83054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83055   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83056   unsigned int arg2 ;
83057   std::vector< Dali::Actor > *arg3 = 0 ;
83058
83059   arg1 = (Dali::Toolkit::TableView *)jarg1;
83060   arg2 = (unsigned int)jarg2;
83061   arg3 = (std::vector< Dali::Actor > *)jarg3;
83062   if (!arg3) {
83063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83064     return ;
83065   }
83066   {
83067     try {
83068       (arg1)->DeleteRow(arg2,*arg3);
83069     } catch (std::out_of_range& e) {
83070       {
83071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83072       };
83073     } catch (std::exception& e) {
83074       {
83075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83076       };
83077     } catch (Dali::DaliException e) {
83078       {
83079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83080       };
83081     } catch (...) {
83082       {
83083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83084       };
83085     }
83086   }
83087
83088 }
83089
83090
83091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83092   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83093   unsigned int arg2 ;
83094
83095   arg1 = (Dali::Toolkit::TableView *)jarg1;
83096   arg2 = (unsigned int)jarg2;
83097   {
83098     try {
83099       (arg1)->InsertColumn(arg2);
83100     } catch (std::out_of_range& e) {
83101       {
83102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83103       };
83104     } catch (std::exception& e) {
83105       {
83106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83107       };
83108     } catch (Dali::DaliException e) {
83109       {
83110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83111       };
83112     } catch (...) {
83113       {
83114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83115       };
83116     }
83117   }
83118
83119 }
83120
83121
83122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83123   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83124   unsigned int arg2 ;
83125
83126   arg1 = (Dali::Toolkit::TableView *)jarg1;
83127   arg2 = (unsigned int)jarg2;
83128   {
83129     try {
83130       (arg1)->DeleteColumn(arg2);
83131     } catch (std::out_of_range& e) {
83132       {
83133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83134       };
83135     } catch (std::exception& e) {
83136       {
83137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83138       };
83139     } catch (Dali::DaliException e) {
83140       {
83141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83142       };
83143     } catch (...) {
83144       {
83145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83146       };
83147     }
83148   }
83149
83150 }
83151
83152
83153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83154   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83155   unsigned int arg2 ;
83156   std::vector< Dali::Actor > *arg3 = 0 ;
83157
83158   arg1 = (Dali::Toolkit::TableView *)jarg1;
83159   arg2 = (unsigned int)jarg2;
83160   arg3 = (std::vector< Dali::Actor > *)jarg3;
83161   if (!arg3) {
83162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83163     return ;
83164   }
83165   {
83166     try {
83167       (arg1)->DeleteColumn(arg2,*arg3);
83168     } catch (std::out_of_range& e) {
83169       {
83170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83171       };
83172     } catch (std::exception& e) {
83173       {
83174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83175       };
83176     } catch (Dali::DaliException e) {
83177       {
83178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83179       };
83180     } catch (...) {
83181       {
83182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83183       };
83184     }
83185   }
83186
83187 }
83188
83189
83190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83191   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83192   unsigned int arg2 ;
83193   unsigned int arg3 ;
83194
83195   arg1 = (Dali::Toolkit::TableView *)jarg1;
83196   arg2 = (unsigned int)jarg2;
83197   arg3 = (unsigned int)jarg3;
83198   {
83199     try {
83200       (arg1)->Resize(arg2,arg3);
83201     } catch (std::out_of_range& e) {
83202       {
83203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83204       };
83205     } catch (std::exception& e) {
83206       {
83207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83208       };
83209     } catch (Dali::DaliException e) {
83210       {
83211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83212       };
83213     } catch (...) {
83214       {
83215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83216       };
83217     }
83218   }
83219
83220 }
83221
83222
83223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83224   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83225   unsigned int arg2 ;
83226   unsigned int arg3 ;
83227   std::vector< Dali::Actor > *arg4 = 0 ;
83228
83229   arg1 = (Dali::Toolkit::TableView *)jarg1;
83230   arg2 = (unsigned int)jarg2;
83231   arg3 = (unsigned int)jarg3;
83232   arg4 = (std::vector< Dali::Actor > *)jarg4;
83233   if (!arg4) {
83234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83235     return ;
83236   }
83237   {
83238     try {
83239       (arg1)->Resize(arg2,arg3,*arg4);
83240     } catch (std::out_of_range& e) {
83241       {
83242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83243       };
83244     } catch (std::exception& e) {
83245       {
83246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83247       };
83248     } catch (Dali::DaliException e) {
83249       {
83250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83251       };
83252     } catch (...) {
83253       {
83254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83255       };
83256     }
83257   }
83258
83259 }
83260
83261
83262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83263   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83264   Dali::Size arg2 ;
83265   Dali::Size *argp2 ;
83266
83267   arg1 = (Dali::Toolkit::TableView *)jarg1;
83268   argp2 = (Dali::Size *)jarg2;
83269   if (!argp2) {
83270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83271     return ;
83272   }
83273   arg2 = *argp2;
83274   {
83275     try {
83276       (arg1)->SetCellPadding(arg2);
83277     } catch (std::out_of_range& e) {
83278       {
83279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83280       };
83281     } catch (std::exception& e) {
83282       {
83283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83284       };
83285     } catch (Dali::DaliException e) {
83286       {
83287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83288       };
83289     } catch (...) {
83290       {
83291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83292       };
83293     }
83294   }
83295
83296 }
83297
83298
83299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83300   void * jresult ;
83301   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83302   Dali::Size result;
83303
83304   arg1 = (Dali::Toolkit::TableView *)jarg1;
83305   {
83306     try {
83307       result = (arg1)->GetCellPadding();
83308     } catch (std::out_of_range& e) {
83309       {
83310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83311       };
83312     } catch (std::exception& e) {
83313       {
83314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83315       };
83316     } catch (Dali::DaliException e) {
83317       {
83318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83319       };
83320     } catch (...) {
83321       {
83322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83323       };
83324     }
83325   }
83326
83327   jresult = new Dali::Size((const Dali::Size &)result);
83328   return jresult;
83329 }
83330
83331
83332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83333   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83334   unsigned int arg2 ;
83335
83336   arg1 = (Dali::Toolkit::TableView *)jarg1;
83337   arg2 = (unsigned int)jarg2;
83338   {
83339     try {
83340       (arg1)->SetFitHeight(arg2);
83341     } catch (std::out_of_range& e) {
83342       {
83343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83344       };
83345     } catch (std::exception& e) {
83346       {
83347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83348       };
83349     } catch (Dali::DaliException e) {
83350       {
83351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83352       };
83353     } catch (...) {
83354       {
83355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83356       };
83357     }
83358   }
83359
83360 }
83361
83362
83363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83364   unsigned int jresult ;
83365   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83366   unsigned int arg2 ;
83367   bool result;
83368
83369   arg1 = (Dali::Toolkit::TableView *)jarg1;
83370   arg2 = (unsigned int)jarg2;
83371   {
83372     try {
83373       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83374     } catch (std::out_of_range& e) {
83375       {
83376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83377       };
83378     } catch (std::exception& e) {
83379       {
83380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83381       };
83382     } catch (Dali::DaliException e) {
83383       {
83384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83385       };
83386     } catch (...) {
83387       {
83388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83389       };
83390     }
83391   }
83392
83393   jresult = result;
83394   return jresult;
83395 }
83396
83397
83398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83399   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83400   unsigned int arg2 ;
83401
83402   arg1 = (Dali::Toolkit::TableView *)jarg1;
83403   arg2 = (unsigned int)jarg2;
83404   {
83405     try {
83406       (arg1)->SetFitWidth(arg2);
83407     } catch (std::out_of_range& e) {
83408       {
83409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83410       };
83411     } catch (std::exception& e) {
83412       {
83413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83414       };
83415     } catch (Dali::DaliException e) {
83416       {
83417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83418       };
83419     } catch (...) {
83420       {
83421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83422       };
83423     }
83424   }
83425
83426 }
83427
83428
83429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83430   unsigned int jresult ;
83431   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83432   unsigned int arg2 ;
83433   bool result;
83434
83435   arg1 = (Dali::Toolkit::TableView *)jarg1;
83436   arg2 = (unsigned int)jarg2;
83437   {
83438     try {
83439       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83440     } catch (std::out_of_range& e) {
83441       {
83442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83443       };
83444     } catch (std::exception& e) {
83445       {
83446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83447       };
83448     } catch (Dali::DaliException e) {
83449       {
83450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83451       };
83452     } catch (...) {
83453       {
83454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83455       };
83456     }
83457   }
83458
83459   jresult = result;
83460   return jresult;
83461 }
83462
83463
83464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83465   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83466   unsigned int arg2 ;
83467   float arg3 ;
83468
83469   arg1 = (Dali::Toolkit::TableView *)jarg1;
83470   arg2 = (unsigned int)jarg2;
83471   arg3 = (float)jarg3;
83472   {
83473     try {
83474       (arg1)->SetFixedHeight(arg2,arg3);
83475     } catch (std::out_of_range& e) {
83476       {
83477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83478       };
83479     } catch (std::exception& e) {
83480       {
83481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83482       };
83483     } catch (Dali::DaliException e) {
83484       {
83485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83486       };
83487     } catch (...) {
83488       {
83489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83490       };
83491     }
83492   }
83493
83494 }
83495
83496
83497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83498   float jresult ;
83499   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83500   unsigned int arg2 ;
83501   float result;
83502
83503   arg1 = (Dali::Toolkit::TableView *)jarg1;
83504   arg2 = (unsigned int)jarg2;
83505   {
83506     try {
83507       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83508     } catch (std::out_of_range& e) {
83509       {
83510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83511       };
83512     } catch (std::exception& e) {
83513       {
83514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83515       };
83516     } catch (Dali::DaliException e) {
83517       {
83518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83519       };
83520     } catch (...) {
83521       {
83522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83523       };
83524     }
83525   }
83526
83527   jresult = result;
83528   return jresult;
83529 }
83530
83531
83532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83533   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83534   unsigned int arg2 ;
83535   float arg3 ;
83536
83537   arg1 = (Dali::Toolkit::TableView *)jarg1;
83538   arg2 = (unsigned int)jarg2;
83539   arg3 = (float)jarg3;
83540   {
83541     try {
83542       (arg1)->SetRelativeHeight(arg2,arg3);
83543     } catch (std::out_of_range& e) {
83544       {
83545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83546       };
83547     } catch (std::exception& e) {
83548       {
83549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83550       };
83551     } catch (Dali::DaliException e) {
83552       {
83553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83554       };
83555     } catch (...) {
83556       {
83557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83558       };
83559     }
83560   }
83561
83562 }
83563
83564
83565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83566   float jresult ;
83567   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83568   unsigned int arg2 ;
83569   float result;
83570
83571   arg1 = (Dali::Toolkit::TableView *)jarg1;
83572   arg2 = (unsigned int)jarg2;
83573   {
83574     try {
83575       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83576     } catch (std::out_of_range& e) {
83577       {
83578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83579       };
83580     } catch (std::exception& e) {
83581       {
83582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83583       };
83584     } catch (Dali::DaliException e) {
83585       {
83586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83587       };
83588     } catch (...) {
83589       {
83590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83591       };
83592     }
83593   }
83594
83595   jresult = result;
83596   return jresult;
83597 }
83598
83599
83600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83601   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83602   unsigned int arg2 ;
83603   float arg3 ;
83604
83605   arg1 = (Dali::Toolkit::TableView *)jarg1;
83606   arg2 = (unsigned int)jarg2;
83607   arg3 = (float)jarg3;
83608   {
83609     try {
83610       (arg1)->SetFixedWidth(arg2,arg3);
83611     } catch (std::out_of_range& e) {
83612       {
83613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83614       };
83615     } catch (std::exception& e) {
83616       {
83617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83618       };
83619     } catch (Dali::DaliException e) {
83620       {
83621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83622       };
83623     } catch (...) {
83624       {
83625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83626       };
83627     }
83628   }
83629
83630 }
83631
83632
83633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83634   float jresult ;
83635   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83636   unsigned int arg2 ;
83637   float result;
83638
83639   arg1 = (Dali::Toolkit::TableView *)jarg1;
83640   arg2 = (unsigned int)jarg2;
83641   {
83642     try {
83643       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83644     } catch (std::out_of_range& e) {
83645       {
83646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83647       };
83648     } catch (std::exception& e) {
83649       {
83650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83651       };
83652     } catch (Dali::DaliException e) {
83653       {
83654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83655       };
83656     } catch (...) {
83657       {
83658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83659       };
83660     }
83661   }
83662
83663   jresult = result;
83664   return jresult;
83665 }
83666
83667
83668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83669   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83670   unsigned int arg2 ;
83671   float arg3 ;
83672
83673   arg1 = (Dali::Toolkit::TableView *)jarg1;
83674   arg2 = (unsigned int)jarg2;
83675   arg3 = (float)jarg3;
83676   {
83677     try {
83678       (arg1)->SetRelativeWidth(arg2,arg3);
83679     } catch (std::out_of_range& e) {
83680       {
83681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83682       };
83683     } catch (std::exception& e) {
83684       {
83685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83686       };
83687     } catch (Dali::DaliException e) {
83688       {
83689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83690       };
83691     } catch (...) {
83692       {
83693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83694       };
83695     }
83696   }
83697
83698 }
83699
83700
83701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83702   float jresult ;
83703   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83704   unsigned int arg2 ;
83705   float result;
83706
83707   arg1 = (Dali::Toolkit::TableView *)jarg1;
83708   arg2 = (unsigned int)jarg2;
83709   {
83710     try {
83711       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83712     } catch (std::out_of_range& e) {
83713       {
83714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83715       };
83716     } catch (std::exception& e) {
83717       {
83718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83719       };
83720     } catch (Dali::DaliException e) {
83721       {
83722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83723       };
83724     } catch (...) {
83725       {
83726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83727       };
83728     }
83729   }
83730
83731   jresult = result;
83732   return jresult;
83733 }
83734
83735
83736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83737   unsigned int jresult ;
83738   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83739   unsigned int result;
83740
83741   arg1 = (Dali::Toolkit::TableView *)jarg1;
83742   {
83743     try {
83744       result = (unsigned int)(arg1)->GetRows();
83745     } catch (std::out_of_range& e) {
83746       {
83747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83748       };
83749     } catch (std::exception& e) {
83750       {
83751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83752       };
83753     } catch (Dali::DaliException e) {
83754       {
83755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83756       };
83757     } catch (...) {
83758       {
83759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83760       };
83761     }
83762   }
83763
83764   jresult = result;
83765   return jresult;
83766 }
83767
83768
83769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83770   unsigned int jresult ;
83771   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83772   unsigned int result;
83773
83774   arg1 = (Dali::Toolkit::TableView *)jarg1;
83775   {
83776     try {
83777       result = (unsigned int)(arg1)->GetColumns();
83778     } catch (std::out_of_range& e) {
83779       {
83780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83781       };
83782     } catch (std::exception& e) {
83783       {
83784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83785       };
83786     } catch (Dali::DaliException e) {
83787       {
83788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83789       };
83790     } catch (...) {
83791       {
83792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83793       };
83794     }
83795   }
83796
83797   jresult = result;
83798   return jresult;
83799 }
83800
83801
83802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83803   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83804   Dali::Toolkit::TableView::CellPosition arg2 ;
83805   Dali::HorizontalAlignment::Type arg3 ;
83806   Dali::VerticalAlignment::Type arg4 ;
83807   Dali::Toolkit::TableView::CellPosition *argp2 ;
83808
83809   arg1 = (Dali::Toolkit::TableView *)jarg1;
83810   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83811   if (!argp2) {
83812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83813     return ;
83814   }
83815   arg2 = *argp2;
83816   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83817   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83818   {
83819     try {
83820       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83821     } catch (std::out_of_range& e) {
83822       {
83823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83824       };
83825     } catch (std::exception& e) {
83826       {
83827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83828       };
83829     } catch (Dali::DaliException e) {
83830       {
83831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83832       };
83833     } catch (...) {
83834       {
83835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83836       };
83837     }
83838   }
83839
83840 }
83841
83842
83843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83844   unsigned int jresult ;
83845   unsigned int result;
83846
83847   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83848   jresult = result;
83849   return jresult;
83850 }
83851
83852
83853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83854   int jresult ;
83855   int result;
83856
83857   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83858   jresult = (int)result;
83859   return jresult;
83860 }
83861
83862
83863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83864   int jresult ;
83865   int result;
83866
83867   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83868   jresult = (int)result;
83869   return jresult;
83870 }
83871
83872
83873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83874   int jresult ;
83875   int result;
83876
83877   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83878   jresult = (int)result;
83879   return jresult;
83880 }
83881
83882
83883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83884   int jresult ;
83885   int result;
83886
83887   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83888   jresult = (int)result;
83889   return jresult;
83890 }
83891
83892
83893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83894   int jresult ;
83895   int result;
83896
83897   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83898   jresult = (int)result;
83899   return jresult;
83900 }
83901
83902
83903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83904   int jresult ;
83905   int result;
83906
83907   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83908   jresult = (int)result;
83909   return jresult;
83910 }
83911
83912
83913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83914   int jresult ;
83915   int result;
83916
83917   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83918   jresult = (int)result;
83919   return jresult;
83920 }
83921
83922
83923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83924   int jresult ;
83925   int result;
83926
83927   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83928   jresult = (int)result;
83929   return jresult;
83930 }
83931
83932
83933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83934   int jresult ;
83935   int result;
83936
83937   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83938   jresult = (int)result;
83939   return jresult;
83940 }
83941
83942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
83943   int jresult ;
83944   int result;
83945
83946   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
83947   jresult = (int)result;
83948   return jresult;
83949 }
83950
83951
83952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
83953   int jresult ;
83954   int result;
83955
83956   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
83957   jresult = (int)result;
83958   return jresult;
83959 }
83960
83961
83962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
83963   int jresult ;
83964   int result;
83965
83966   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
83967   jresult = (int)result;
83968   return jresult;
83969 }
83970
83971
83972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
83973   int jresult ;
83974   int result;
83975
83976   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
83977   jresult = (int)result;
83978   return jresult;
83979 }
83980
83981
83982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
83983   int jresult ;
83984   int result;
83985
83986   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
83987   jresult = (int)result;
83988   return jresult;
83989 }
83990
83991
83992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83993   int jresult ;
83994   int result;
83995
83996   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83997   jresult = (int)result;
83998   return jresult;
83999 }
84000
84001
84002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84003   int jresult ;
84004   int result;
84005
84006   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84007   jresult = (int)result;
84008   return jresult;
84009 }
84010
84011
84012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84013   int jresult ;
84014   int result;
84015
84016   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84017   jresult = (int)result;
84018   return jresult;
84019 }
84020
84021
84022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84023   int jresult ;
84024   int result;
84025
84026   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84027   jresult = (int)result;
84028   return jresult;
84029 }
84030
84031
84032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84033   int jresult ;
84034   int result;
84035
84036   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84037   jresult = (int)result;
84038   return jresult;
84039 }
84040
84041
84042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84043   int jresult ;
84044   int result;
84045
84046   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84047   jresult = (int)result;
84048   return jresult;
84049 }
84050
84051
84052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84053   int jresult ;
84054   int result;
84055
84056   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84057   jresult = (int)result;
84058   return jresult;
84059 }
84060
84061
84062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84063   int jresult ;
84064   int result;
84065
84066   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84067   jresult = (int)result;
84068   return jresult;
84069 }
84070
84071
84072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84073   int jresult ;
84074   int result;
84075
84076   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84077   jresult = (int)result;
84078   return jresult;
84079 }
84080
84081
84082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84083   int jresult ;
84084   int result;
84085
84086   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84087   jresult = (int)result;
84088   return jresult;
84089 }
84090
84091
84092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84093   void * jresult ;
84094   Dali::Toolkit::TextLabel::Property *result = 0 ;
84095
84096   {
84097     try {
84098       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84099     } catch (std::out_of_range& e) {
84100       {
84101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84102       };
84103     } catch (std::exception& e) {
84104       {
84105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84106       };
84107     } catch (Dali::DaliException e) {
84108       {
84109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84110       };
84111     } catch (...) {
84112       {
84113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84114       };
84115     }
84116   }
84117
84118   jresult = (void *)result;
84119   return jresult;
84120 }
84121
84122
84123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84124   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84125
84126   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84127   {
84128     try {
84129       delete arg1;
84130     } catch (std::out_of_range& e) {
84131       {
84132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84133       };
84134     } catch (std::exception& e) {
84135       {
84136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84137       };
84138     } catch (Dali::DaliException e) {
84139       {
84140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84141       };
84142     } catch (...) {
84143       {
84144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84145       };
84146     }
84147   }
84148
84149 }
84150
84151
84152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84153   void * jresult ;
84154   Dali::Toolkit::TextLabel result;
84155
84156   {
84157     try {
84158       result = Dali::Toolkit::TextLabel::New();
84159     } catch (std::out_of_range& e) {
84160       {
84161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84162       };
84163     } catch (std::exception& e) {
84164       {
84165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84166       };
84167     } catch (Dali::DaliException e) {
84168       {
84169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84170       };
84171     } catch (...) {
84172       {
84173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84174       };
84175     }
84176   }
84177
84178   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84179   return jresult;
84180 }
84181
84182
84183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84184   void * jresult ;
84185   std::string *arg1 = 0 ;
84186   Dali::Toolkit::TextLabel result;
84187
84188   if (!jarg1) {
84189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84190     return 0;
84191   }
84192   std::string arg1_str(jarg1);
84193   arg1 = &arg1_str;
84194   {
84195     try {
84196       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84197     } catch (std::out_of_range& e) {
84198       {
84199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84200       };
84201     } catch (std::exception& e) {
84202       {
84203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84204       };
84205     } catch (Dali::DaliException e) {
84206       {
84207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84208       };
84209     } catch (...) {
84210       {
84211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84212       };
84213     }
84214   }
84215
84216   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84217
84218   //argout typemap for const std::string&
84219
84220   return jresult;
84221 }
84222
84223
84224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84225   void * jresult ;
84226   Dali::Toolkit::TextLabel *result = 0 ;
84227
84228   {
84229     try {
84230       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84231     } catch (std::out_of_range& e) {
84232       {
84233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84234       };
84235     } catch (std::exception& e) {
84236       {
84237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84238       };
84239     } catch (Dali::DaliException e) {
84240       {
84241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84242       };
84243     } catch (...) {
84244       {
84245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84246       };
84247     }
84248   }
84249
84250   jresult = (void *)result;
84251   return jresult;
84252 }
84253
84254
84255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84256   void * jresult ;
84257   Dali::Toolkit::TextLabel *arg1 = 0 ;
84258   Dali::Toolkit::TextLabel *result = 0 ;
84259
84260   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84261   if (!arg1) {
84262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84263     return 0;
84264   }
84265   {
84266     try {
84267       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84268     } catch (std::out_of_range& e) {
84269       {
84270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84271       };
84272     } catch (std::exception& e) {
84273       {
84274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84275       };
84276     } catch (Dali::DaliException e) {
84277       {
84278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84279       };
84280     } catch (...) {
84281       {
84282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84283       };
84284     }
84285   }
84286
84287   jresult = (void *)result;
84288   return jresult;
84289 }
84290
84291
84292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84293   void * jresult ;
84294   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84295   Dali::Toolkit::TextLabel *arg2 = 0 ;
84296   Dali::Toolkit::TextLabel *result = 0 ;
84297
84298   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84299   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84300   if (!arg2) {
84301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84302     return 0;
84303   }
84304   {
84305     try {
84306       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84307     } catch (std::out_of_range& e) {
84308       {
84309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84310       };
84311     } catch (std::exception& e) {
84312       {
84313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84314       };
84315     } catch (Dali::DaliException e) {
84316       {
84317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84318       };
84319     } catch (...) {
84320       {
84321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84322       };
84323     }
84324   }
84325
84326   jresult = (void *)result;
84327   return jresult;
84328 }
84329
84330
84331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84332   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84333
84334   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84335   {
84336     try {
84337       delete arg1;
84338     } catch (std::out_of_range& e) {
84339       {
84340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84341       };
84342     } catch (std::exception& e) {
84343       {
84344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84345       };
84346     } catch (Dali::DaliException e) {
84347       {
84348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84349       };
84350     } catch (...) {
84351       {
84352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84353       };
84354     }
84355   }
84356
84357 }
84358
84359
84360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84361   void * jresult ;
84362   Dali::BaseHandle arg1 ;
84363   Dali::BaseHandle *argp1 ;
84364   Dali::Toolkit::TextLabel result;
84365
84366   argp1 = (Dali::BaseHandle *)jarg1;
84367   if (!argp1) {
84368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84369     return 0;
84370   }
84371   arg1 = *argp1;
84372   {
84373     try {
84374       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84375     } catch (std::out_of_range& e) {
84376       {
84377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84378       };
84379     } catch (std::exception& e) {
84380       {
84381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84382       };
84383     } catch (Dali::DaliException e) {
84384       {
84385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84386       };
84387     } catch (...) {
84388       {
84389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84390       };
84391     }
84392   }
84393
84394   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84395   return jresult;
84396 }
84397
84398
84399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84400   void * jresult ;
84401   Dali::Toolkit::AccessibilityManager *result = 0 ;
84402
84403   {
84404     try {
84405       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84406     } catch (std::out_of_range& e) {
84407       {
84408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84409       };
84410     } catch (std::exception& e) {
84411       {
84412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84413       };
84414     } catch (Dali::DaliException e) {
84415       {
84416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84417       };
84418     } catch (...) {
84419       {
84420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84421       };
84422     }
84423   }
84424
84425   jresult = (void *)result;
84426   return jresult;
84427 }
84428
84429
84430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84431   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84432
84433   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84434   {
84435     try {
84436       delete arg1;
84437     } catch (std::out_of_range& e) {
84438       {
84439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84440       };
84441     } catch (std::exception& e) {
84442       {
84443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84444       };
84445     } catch (Dali::DaliException e) {
84446       {
84447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84448       };
84449     } catch (...) {
84450       {
84451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84452       };
84453     }
84454   }
84455
84456 }
84457
84458
84459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84460   void * jresult ;
84461   Dali::Toolkit::AccessibilityManager result;
84462
84463   {
84464     try {
84465       result = Dali::Toolkit::AccessibilityManager::Get();
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 = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84486   return jresult;
84487 }
84488
84489
84490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84491   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84492   Dali::Actor arg2 ;
84493   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84494   std::string *arg4 = 0 ;
84495   Dali::Actor *argp2 ;
84496
84497   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84498   argp2 = (Dali::Actor *)jarg2;
84499   if (!argp2) {
84500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84501     return ;
84502   }
84503   arg2 = *argp2;
84504   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84505   if (!jarg4) {
84506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84507     return ;
84508   }
84509   std::string arg4_str(jarg4);
84510   arg4 = &arg4_str;
84511   {
84512     try {
84513       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84514     } catch (std::out_of_range& e) {
84515       {
84516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84517       };
84518     } catch (std::exception& e) {
84519       {
84520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84521       };
84522     } catch (Dali::DaliException e) {
84523       {
84524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84525       };
84526     } catch (...) {
84527       {
84528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84529       };
84530     }
84531   }
84532
84533
84534   //argout typemap for const std::string&
84535
84536 }
84537
84538
84539 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84540   char * jresult ;
84541   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84542   Dali::Actor arg2 ;
84543   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84544   Dali::Actor *argp2 ;
84545   std::string result;
84546
84547   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84548   argp2 = (Dali::Actor *)jarg2;
84549   if (!argp2) {
84550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84551     return 0;
84552   }
84553   arg2 = *argp2;
84554   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84555   {
84556     try {
84557       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84558     } catch (std::out_of_range& e) {
84559       {
84560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84561       };
84562     } catch (std::exception& e) {
84563       {
84564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84565       };
84566     } catch (Dali::DaliException e) {
84567       {
84568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84569       };
84570     } catch (...) {
84571       {
84572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84573       };
84574     }
84575   }
84576
84577   jresult = SWIG_csharp_string_callback((&result)->c_str());
84578   return jresult;
84579 }
84580
84581
84582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84583   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84584   Dali::Actor arg2 ;
84585   unsigned int arg3 ;
84586   Dali::Actor *argp2 ;
84587
84588   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84589   argp2 = (Dali::Actor *)jarg2;
84590   if (!argp2) {
84591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84592     return ;
84593   }
84594   arg2 = *argp2;
84595   arg3 = (unsigned int)jarg3;
84596   {
84597     try {
84598       (arg1)->SetFocusOrder(arg2,arg3);
84599     } catch (std::out_of_range& e) {
84600       {
84601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84602       };
84603     } catch (std::exception& e) {
84604       {
84605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84606       };
84607     } catch (Dali::DaliException e) {
84608       {
84609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84610       };
84611     } catch (...) {
84612       {
84613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84614       };
84615     }
84616   }
84617
84618 }
84619
84620
84621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84622   unsigned int jresult ;
84623   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84624   Dali::Actor arg2 ;
84625   Dali::Actor *argp2 ;
84626   unsigned int result;
84627
84628   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84629   argp2 = (Dali::Actor *)jarg2;
84630   if (!argp2) {
84631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84632     return 0;
84633   }
84634   arg2 = *argp2;
84635   {
84636     try {
84637       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84638     } catch (std::out_of_range& e) {
84639       {
84640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84641       };
84642     } catch (std::exception& e) {
84643       {
84644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84645       };
84646     } catch (Dali::DaliException e) {
84647       {
84648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84649       };
84650     } catch (...) {
84651       {
84652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84653       };
84654     }
84655   }
84656
84657   jresult = result;
84658   return jresult;
84659 }
84660
84661
84662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84663   unsigned int jresult ;
84664   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84665   unsigned int result;
84666
84667   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84668   {
84669     try {
84670       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84671     } catch (std::out_of_range& e) {
84672       {
84673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84674       };
84675     } catch (std::exception& e) {
84676       {
84677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84678       };
84679     } catch (Dali::DaliException e) {
84680       {
84681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84682       };
84683     } catch (...) {
84684       {
84685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84686       };
84687     }
84688   }
84689
84690   jresult = result;
84691   return jresult;
84692 }
84693
84694
84695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84696   void * jresult ;
84697   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84698   unsigned int arg2 ;
84699   Dali::Actor result;
84700
84701   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84702   arg2 = (unsigned int)jarg2;
84703   {
84704     try {
84705       result = (arg1)->GetActorByFocusOrder(arg2);
84706     } catch (std::out_of_range& e) {
84707       {
84708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84709       };
84710     } catch (std::exception& e) {
84711       {
84712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84713       };
84714     } catch (Dali::DaliException e) {
84715       {
84716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84717       };
84718     } catch (...) {
84719       {
84720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84721       };
84722     }
84723   }
84724
84725   jresult = new Dali::Actor((const Dali::Actor &)result);
84726   return jresult;
84727 }
84728
84729
84730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84731   unsigned int jresult ;
84732   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84733   Dali::Actor arg2 ;
84734   Dali::Actor *argp2 ;
84735   bool result;
84736
84737   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84738   argp2 = (Dali::Actor *)jarg2;
84739   if (!argp2) {
84740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84741     return 0;
84742   }
84743   arg2 = *argp2;
84744   {
84745     try {
84746       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84747     } catch (std::out_of_range& e) {
84748       {
84749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84750       };
84751     } catch (std::exception& e) {
84752       {
84753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84754       };
84755     } catch (Dali::DaliException e) {
84756       {
84757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84758       };
84759     } catch (...) {
84760       {
84761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84762       };
84763     }
84764   }
84765
84766   jresult = result;
84767   return jresult;
84768 }
84769
84770
84771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84772   void * jresult ;
84773   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84774   Dali::Actor result;
84775
84776   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84777   {
84778     try {
84779       result = (arg1)->GetCurrentFocusActor();
84780     } catch (std::out_of_range& e) {
84781       {
84782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84783       };
84784     } catch (std::exception& e) {
84785       {
84786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84787       };
84788     } catch (Dali::DaliException e) {
84789       {
84790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84791       };
84792     } catch (...) {
84793       {
84794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84795       };
84796     }
84797   }
84798
84799   jresult = new Dali::Actor((const Dali::Actor &)result);
84800   return jresult;
84801 }
84802
84803
84804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84805   void * jresult ;
84806   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84807   Dali::Actor result;
84808
84809   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84810   {
84811     try {
84812       result = (arg1)->GetCurrentFocusGroup();
84813     } catch (std::out_of_range& e) {
84814       {
84815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84816       };
84817     } catch (std::exception& e) {
84818       {
84819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84820       };
84821     } catch (Dali::DaliException e) {
84822       {
84823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84824       };
84825     } catch (...) {
84826       {
84827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84828       };
84829     }
84830   }
84831
84832   jresult = new Dali::Actor((const Dali::Actor &)result);
84833   return jresult;
84834 }
84835
84836
84837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84838   unsigned int jresult ;
84839   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84840   unsigned int result;
84841
84842   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84843   {
84844     try {
84845       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84846     } catch (std::out_of_range& e) {
84847       {
84848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84849       };
84850     } catch (std::exception& e) {
84851       {
84852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84853       };
84854     } catch (Dali::DaliException e) {
84855       {
84856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84857       };
84858     } catch (...) {
84859       {
84860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84861       };
84862     }
84863   }
84864
84865   jresult = result;
84866   return jresult;
84867 }
84868
84869
84870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84871   unsigned int jresult ;
84872   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84873   bool result;
84874
84875   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84876   {
84877     try {
84878       result = (bool)(arg1)->MoveFocusForward();
84879     } catch (std::out_of_range& e) {
84880       {
84881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84882       };
84883     } catch (std::exception& e) {
84884       {
84885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84886       };
84887     } catch (Dali::DaliException e) {
84888       {
84889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84890       };
84891     } catch (...) {
84892       {
84893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84894       };
84895     }
84896   }
84897
84898   jresult = result;
84899   return jresult;
84900 }
84901
84902
84903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84904   unsigned int jresult ;
84905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84906   bool result;
84907
84908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84909   {
84910     try {
84911       result = (bool)(arg1)->MoveFocusBackward();
84912     } catch (std::out_of_range& e) {
84913       {
84914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84915       };
84916     } catch (std::exception& e) {
84917       {
84918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84919       };
84920     } catch (Dali::DaliException e) {
84921       {
84922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84923       };
84924     } catch (...) {
84925       {
84926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84927       };
84928     }
84929   }
84930
84931   jresult = result;
84932   return jresult;
84933 }
84934
84935
84936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84937   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84938
84939   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84940   {
84941     try {
84942       (arg1)->ClearFocus();
84943     } catch (std::out_of_range& e) {
84944       {
84945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84946       };
84947     } catch (std::exception& e) {
84948       {
84949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84950       };
84951     } catch (Dali::DaliException e) {
84952       {
84953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84954       };
84955     } catch (...) {
84956       {
84957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84958       };
84959     }
84960   }
84961
84962 }
84963
84964
84965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84966   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84967
84968   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84969   {
84970     try {
84971       (arg1)->Reset();
84972     } catch (std::out_of_range& e) {
84973       {
84974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84975       };
84976     } catch (std::exception& e) {
84977       {
84978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84979       };
84980     } catch (Dali::DaliException e) {
84981       {
84982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84983       };
84984     } catch (...) {
84985       {
84986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84987       };
84988     }
84989   }
84990
84991 }
84992
84993
84994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
84995   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84996   Dali::Actor arg2 ;
84997   bool arg3 ;
84998   Dali::Actor *argp2 ;
84999
85000   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85001   argp2 = (Dali::Actor *)jarg2;
85002   if (!argp2) {
85003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85004     return ;
85005   }
85006   arg2 = *argp2;
85007   arg3 = jarg3 ? true : false;
85008   {
85009     try {
85010       (arg1)->SetFocusGroup(arg2,arg3);
85011     } catch (std::out_of_range& e) {
85012       {
85013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85014       };
85015     } catch (std::exception& e) {
85016       {
85017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85018       };
85019     } catch (Dali::DaliException e) {
85020       {
85021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85022       };
85023     } catch (...) {
85024       {
85025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85026       };
85027     }
85028   }
85029
85030 }
85031
85032
85033 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85034   unsigned int jresult ;
85035   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85036   Dali::Actor arg2 ;
85037   Dali::Actor *argp2 ;
85038   bool result;
85039
85040   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85041   argp2 = (Dali::Actor *)jarg2;
85042   if (!argp2) {
85043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85044     return 0;
85045   }
85046   arg2 = *argp2;
85047   {
85048     try {
85049       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85050     } catch (std::out_of_range& e) {
85051       {
85052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85053       };
85054     } catch (std::exception& e) {
85055       {
85056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85057       };
85058     } catch (Dali::DaliException e) {
85059       {
85060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85061       };
85062     } catch (...) {
85063       {
85064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85065       };
85066     }
85067   }
85068
85069   jresult = result;
85070   return jresult;
85071 }
85072
85073
85074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85075   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85076   bool arg2 ;
85077
85078   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85079   arg2 = jarg2 ? true : false;
85080   {
85081     try {
85082       (arg1)->SetGroupMode(arg2);
85083     } catch (std::out_of_range& e) {
85084       {
85085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85086       };
85087     } catch (std::exception& e) {
85088       {
85089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85090       };
85091     } catch (Dali::DaliException e) {
85092       {
85093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85094       };
85095     } catch (...) {
85096       {
85097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85098       };
85099     }
85100   }
85101
85102 }
85103
85104
85105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85106   unsigned int jresult ;
85107   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85108   bool result;
85109
85110   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85111   {
85112     try {
85113       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85114     } catch (std::out_of_range& e) {
85115       {
85116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85117       };
85118     } catch (std::exception& e) {
85119       {
85120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85121       };
85122     } catch (Dali::DaliException e) {
85123       {
85124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85125       };
85126     } catch (...) {
85127       {
85128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85129       };
85130     }
85131   }
85132
85133   jresult = result;
85134   return jresult;
85135 }
85136
85137
85138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85139   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85140   bool arg2 ;
85141
85142   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85143   arg2 = jarg2 ? true : false;
85144   {
85145     try {
85146       (arg1)->SetWrapMode(arg2);
85147     } catch (std::out_of_range& e) {
85148       {
85149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85150       };
85151     } catch (std::exception& e) {
85152       {
85153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85154       };
85155     } catch (Dali::DaliException e) {
85156       {
85157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85158       };
85159     } catch (...) {
85160       {
85161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85162       };
85163     }
85164   }
85165
85166 }
85167
85168
85169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85170   unsigned int jresult ;
85171   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85172   bool result;
85173
85174   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85175   {
85176     try {
85177       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85178     } catch (std::out_of_range& e) {
85179       {
85180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85181       };
85182     } catch (std::exception& e) {
85183       {
85184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85185       };
85186     } catch (Dali::DaliException e) {
85187       {
85188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85189       };
85190     } catch (...) {
85191       {
85192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85193       };
85194     }
85195   }
85196
85197   jresult = result;
85198   return jresult;
85199 }
85200
85201
85202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85203   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85204   Dali::Actor arg2 ;
85205   Dali::Actor *argp2 ;
85206
85207   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85208   argp2 = (Dali::Actor *)jarg2;
85209   if (!argp2) {
85210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85211     return ;
85212   }
85213   arg2 = *argp2;
85214   {
85215     try {
85216       (arg1)->SetFocusIndicatorActor(arg2);
85217     } catch (std::out_of_range& e) {
85218       {
85219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85220       };
85221     } catch (std::exception& e) {
85222       {
85223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85224       };
85225     } catch (Dali::DaliException e) {
85226       {
85227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85228       };
85229     } catch (...) {
85230       {
85231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85232       };
85233     }
85234   }
85235
85236 }
85237
85238
85239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85240   void * jresult ;
85241   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85242   Dali::Actor result;
85243
85244   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85245   {
85246     try {
85247       result = (arg1)->GetFocusIndicatorActor();
85248     } catch (std::out_of_range& e) {
85249       {
85250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85251       };
85252     } catch (std::exception& e) {
85253       {
85254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85255       };
85256     } catch (Dali::DaliException e) {
85257       {
85258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85259       };
85260     } catch (...) {
85261       {
85262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85263       };
85264     }
85265   }
85266
85267   jresult = new Dali::Actor((const Dali::Actor &)result);
85268   return jresult;
85269 }
85270
85271
85272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85273   void * jresult ;
85274   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85275   Dali::Actor arg2 ;
85276   Dali::Actor *argp2 ;
85277   Dali::Actor result;
85278
85279   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85280   argp2 = (Dali::Actor *)jarg2;
85281   if (!argp2) {
85282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85283     return 0;
85284   }
85285   arg2 = *argp2;
85286   {
85287     try {
85288       result = (arg1)->GetFocusGroup(arg2);
85289     } catch (std::out_of_range& e) {
85290       {
85291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85292       };
85293     } catch (std::exception& e) {
85294       {
85295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85296       };
85297     } catch (Dali::DaliException e) {
85298       {
85299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85300       };
85301     } catch (...) {
85302       {
85303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85304       };
85305     }
85306   }
85307
85308   jresult = new Dali::Actor((const Dali::Actor &)result);
85309   return jresult;
85310 }
85311
85312
85313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85314   void * jresult ;
85315   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85316   Dali::Vector2 result;
85317
85318   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85319   {
85320     try {
85321       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85322     } catch (std::out_of_range& e) {
85323       {
85324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85325       };
85326     } catch (std::exception& e) {
85327       {
85328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85329       };
85330     } catch (Dali::DaliException e) {
85331       {
85332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85333       };
85334     } catch (...) {
85335       {
85336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85337       };
85338     }
85339   }
85340
85341   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85342   return jresult;
85343 }
85344
85345
85346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85347   void * jresult ;
85348   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85349   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85350
85351   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85352   {
85353     try {
85354       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85355     } catch (std::out_of_range& e) {
85356       {
85357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85358       };
85359     } catch (std::exception& e) {
85360       {
85361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85362       };
85363     } catch (Dali::DaliException e) {
85364       {
85365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85366       };
85367     } catch (...) {
85368       {
85369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85370       };
85371     }
85372   }
85373
85374   jresult = (void *)result;
85375   return jresult;
85376 }
85377
85378
85379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85380   void * jresult ;
85381   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85382   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85383
85384   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85385   {
85386     try {
85387       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85388     } catch (std::out_of_range& e) {
85389       {
85390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85391       };
85392     } catch (std::exception& e) {
85393       {
85394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85395       };
85396     } catch (Dali::DaliException e) {
85397       {
85398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85399       };
85400     } catch (...) {
85401       {
85402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85403       };
85404     }
85405   }
85406
85407   jresult = (void *)result;
85408   return jresult;
85409 }
85410
85411
85412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85413   void * jresult ;
85414   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85415   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85416
85417   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85418   {
85419     try {
85420       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85421     } catch (std::out_of_range& e) {
85422       {
85423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85424       };
85425     } catch (std::exception& e) {
85426       {
85427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85428       };
85429     } catch (Dali::DaliException e) {
85430       {
85431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85432       };
85433     } catch (...) {
85434       {
85435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85436       };
85437     }
85438   }
85439
85440   jresult = (void *)result;
85441   return jresult;
85442 }
85443
85444
85445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85446   void * jresult ;
85447   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85448   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85449
85450   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85451   {
85452     try {
85453       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85454     } catch (std::out_of_range& e) {
85455       {
85456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85457       };
85458     } catch (std::exception& e) {
85459       {
85460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85461       };
85462     } catch (Dali::DaliException e) {
85463       {
85464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85465       };
85466     } catch (...) {
85467       {
85468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85469       };
85470     }
85471   }
85472
85473   jresult = (void *)result;
85474   return jresult;
85475 }
85476
85477
85478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85479   void * jresult ;
85480   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85481   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85482
85483   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85484   {
85485     try {
85486       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85487     } catch (std::out_of_range& e) {
85488       {
85489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85490       };
85491     } catch (std::exception& e) {
85492       {
85493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85494       };
85495     } catch (Dali::DaliException e) {
85496       {
85497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85498       };
85499     } catch (...) {
85500       {
85501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85502       };
85503     }
85504   }
85505
85506   jresult = (void *)result;
85507   return jresult;
85508 }
85509
85510
85511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85512   void * jresult ;
85513   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85514   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85515
85516   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85517   {
85518     try {
85519       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85520     } catch (std::out_of_range& e) {
85521       {
85522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85523       };
85524     } catch (std::exception& e) {
85525       {
85526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85527       };
85528     } catch (Dali::DaliException e) {
85529       {
85530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85531       };
85532     } catch (...) {
85533       {
85534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85535       };
85536     }
85537   }
85538
85539   jresult = (void *)result;
85540   return jresult;
85541 }
85542
85543
85544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85545   void * jresult ;
85546   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85547   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85548
85549   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85550   {
85551     try {
85552       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85553     } catch (std::out_of_range& e) {
85554       {
85555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85556       };
85557     } catch (std::exception& e) {
85558       {
85559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85560       };
85561     } catch (Dali::DaliException e) {
85562       {
85563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85564       };
85565     } catch (...) {
85566       {
85567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85568       };
85569     }
85570   }
85571
85572   jresult = (void *)result;
85573   return jresult;
85574 }
85575
85576
85577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85578   void * jresult ;
85579   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85580   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85581
85582   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85583   {
85584     try {
85585       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85586     } catch (std::out_of_range& e) {
85587       {
85588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85589       };
85590     } catch (std::exception& e) {
85591       {
85592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85593       };
85594     } catch (Dali::DaliException e) {
85595       {
85596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85597       };
85598     } catch (...) {
85599       {
85600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85601       };
85602     }
85603   }
85604
85605   jresult = (void *)result;
85606   return jresult;
85607 }
85608
85609
85610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85611   void * jresult ;
85612   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85613   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85614
85615   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85616   {
85617     try {
85618       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85619     } catch (std::out_of_range& e) {
85620       {
85621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85622       };
85623     } catch (std::exception& e) {
85624       {
85625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85626       };
85627     } catch (Dali::DaliException e) {
85628       {
85629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85630       };
85631     } catch (...) {
85632       {
85633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85634       };
85635     }
85636   }
85637
85638   jresult = (void *)result;
85639   return jresult;
85640 }
85641
85642
85643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85644   void * jresult ;
85645   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85646   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85647
85648   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85649   {
85650     try {
85651       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85652     } catch (std::out_of_range& e) {
85653       {
85654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85655       };
85656     } catch (std::exception& e) {
85657       {
85658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85659       };
85660     } catch (Dali::DaliException e) {
85661       {
85662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85663       };
85664     } catch (...) {
85665       {
85666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85667       };
85668     }
85669   }
85670
85671   jresult = (void *)result;
85672   return jresult;
85673 }
85674
85675
85676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85677   void * jresult ;
85678   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85679   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85680
85681   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85682   {
85683     try {
85684       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85685     } catch (std::out_of_range& e) {
85686       {
85687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85688       };
85689     } catch (std::exception& e) {
85690       {
85691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85692       };
85693     } catch (Dali::DaliException e) {
85694       {
85695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85696       };
85697     } catch (...) {
85698       {
85699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85700       };
85701     }
85702   }
85703
85704   jresult = (void *)result;
85705   return jresult;
85706 }
85707
85708
85709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85710   void * jresult ;
85711   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85712   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85713
85714   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85715   {
85716     try {
85717       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85718     } catch (std::out_of_range& e) {
85719       {
85720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85721       };
85722     } catch (std::exception& e) {
85723       {
85724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85725       };
85726     } catch (Dali::DaliException e) {
85727       {
85728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85729       };
85730     } catch (...) {
85731       {
85732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85733       };
85734     }
85735   }
85736
85737   jresult = (void *)result;
85738   return jresult;
85739 }
85740
85741
85742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85743   void * jresult ;
85744   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85745   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85746
85747   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85748   {
85749     try {
85750       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85751     } catch (std::out_of_range& e) {
85752       {
85753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85754       };
85755     } catch (std::exception& e) {
85756       {
85757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85758       };
85759     } catch (Dali::DaliException e) {
85760       {
85761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85762       };
85763     } catch (...) {
85764       {
85765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85766       };
85767     }
85768   }
85769
85770   jresult = (void *)result;
85771   return jresult;
85772 }
85773
85774
85775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85776   void * jresult ;
85777   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85778   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85779
85780   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85781   {
85782     try {
85783       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85784     } catch (std::out_of_range& e) {
85785       {
85786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85787       };
85788     } catch (std::exception& e) {
85789       {
85790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85791       };
85792     } catch (Dali::DaliException e) {
85793       {
85794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85795       };
85796     } catch (...) {
85797       {
85798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85799       };
85800     }
85801   }
85802
85803   jresult = (void *)result;
85804   return jresult;
85805 }
85806
85807
85808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85809   void * jresult ;
85810   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85811   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85812
85813   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85814   {
85815     try {
85816       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85817     } catch (std::out_of_range& e) {
85818       {
85819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85820       };
85821     } catch (std::exception& e) {
85822       {
85823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85824       };
85825     } catch (Dali::DaliException e) {
85826       {
85827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85828       };
85829     } catch (...) {
85830       {
85831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85832       };
85833     }
85834   }
85835
85836   jresult = (void *)result;
85837   return jresult;
85838 }
85839
85840
85841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85842   void * jresult ;
85843   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85844   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85845
85846   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85847   {
85848     try {
85849       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85850     } catch (std::out_of_range& e) {
85851       {
85852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85853       };
85854     } catch (std::exception& e) {
85855       {
85856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85857       };
85858     } catch (Dali::DaliException e) {
85859       {
85860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85861       };
85862     } catch (...) {
85863       {
85864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85865       };
85866     }
85867   }
85868
85869   jresult = (void *)result;
85870   return jresult;
85871 }
85872
85873
85874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85875   void * jresult ;
85876   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85877   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85878
85879   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85880   {
85881     try {
85882       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85883     } catch (std::out_of_range& e) {
85884       {
85885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85886       };
85887     } catch (std::exception& e) {
85888       {
85889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85890       };
85891     } catch (Dali::DaliException e) {
85892       {
85893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85894       };
85895     } catch (...) {
85896       {
85897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85898       };
85899     }
85900   }
85901
85902   jresult = (void *)result;
85903   return jresult;
85904 }
85905
85906
85907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85908   void * jresult ;
85909   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85910   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85911
85912   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85913   {
85914     try {
85915       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85916     } catch (std::out_of_range& e) {
85917       {
85918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85919       };
85920     } catch (std::exception& e) {
85921       {
85922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85923       };
85924     } catch (Dali::DaliException e) {
85925       {
85926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85927       };
85928     } catch (...) {
85929       {
85930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85931       };
85932     }
85933   }
85934
85935   jresult = (void *)result;
85936   return jresult;
85937 }
85938
85939
85940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85941   void * jresult ;
85942   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85943   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85944
85945   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85946   {
85947     try {
85948       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85949     } catch (std::out_of_range& e) {
85950       {
85951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85952       };
85953     } catch (std::exception& e) {
85954       {
85955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85956       };
85957     } catch (Dali::DaliException e) {
85958       {
85959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85960       };
85961     } catch (...) {
85962       {
85963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85964       };
85965     }
85966   }
85967
85968   jresult = (void *)result;
85969   return jresult;
85970 }
85971
85972
85973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85974   void * jresult ;
85975   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85976   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85977
85978   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85979   {
85980     try {
85981       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85982     } catch (std::out_of_range& e) {
85983       {
85984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85985       };
85986     } catch (std::exception& e) {
85987       {
85988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85989       };
85990     } catch (Dali::DaliException e) {
85991       {
85992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85993       };
85994     } catch (...) {
85995       {
85996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85997       };
85998     }
85999   }
86000
86001   jresult = (void *)result;
86002   return jresult;
86003 }
86004
86005
86006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86007   void * jresult ;
86008   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86009   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86010
86011   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86012   {
86013     try {
86014       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86015     } catch (std::out_of_range& e) {
86016       {
86017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86018       };
86019     } catch (std::exception& e) {
86020       {
86021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86022       };
86023     } catch (Dali::DaliException e) {
86024       {
86025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86026       };
86027     } catch (...) {
86028       {
86029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86030       };
86031     }
86032   }
86033
86034   jresult = (void *)result;
86035   return jresult;
86036 }
86037
86038
86039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86040   void * jresult ;
86041   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86042   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86043
86044   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86045   {
86046     try {
86047       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86048     } catch (std::out_of_range& e) {
86049       {
86050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86051       };
86052     } catch (std::exception& e) {
86053       {
86054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86055       };
86056     } catch (Dali::DaliException e) {
86057       {
86058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86059       };
86060     } catch (...) {
86061       {
86062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86063       };
86064     }
86065   }
86066
86067   jresult = (void *)result;
86068   return jresult;
86069 }
86070
86071
86072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86073   void * jresult ;
86074   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86075   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86076
86077   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86078   {
86079     try {
86080       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86081     } catch (std::out_of_range& e) {
86082       {
86083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86084       };
86085     } catch (std::exception& e) {
86086       {
86087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86088       };
86089     } catch (Dali::DaliException e) {
86090       {
86091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86092       };
86093     } catch (...) {
86094       {
86095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86096       };
86097     }
86098   }
86099
86100   jresult = (void *)result;
86101   return jresult;
86102 }
86103
86104
86105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86106   void * jresult ;
86107   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86108   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86109
86110   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86111   {
86112     try {
86113       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86114     } catch (std::out_of_range& e) {
86115       {
86116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86117       };
86118     } catch (std::exception& e) {
86119       {
86120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86121       };
86122     } catch (Dali::DaliException e) {
86123       {
86124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86125       };
86126     } catch (...) {
86127       {
86128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86129       };
86130     }
86131   }
86132
86133   jresult = (void *)result;
86134   return jresult;
86135 }
86136
86137
86138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86139   void * jresult ;
86140   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86141   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86142
86143   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86144   {
86145     try {
86146       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86147     } catch (std::out_of_range& e) {
86148       {
86149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86150       };
86151     } catch (std::exception& e) {
86152       {
86153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86154       };
86155     } catch (Dali::DaliException e) {
86156       {
86157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86158       };
86159     } catch (...) {
86160       {
86161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86162       };
86163     }
86164   }
86165
86166   jresult = (void *)result;
86167   return jresult;
86168 }
86169
86170
86171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86172   void * jresult ;
86173   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86174   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86175
86176   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86177   {
86178     try {
86179       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86180     } catch (std::out_of_range& e) {
86181       {
86182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86183       };
86184     } catch (std::exception& e) {
86185       {
86186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86187       };
86188     } catch (Dali::DaliException e) {
86189       {
86190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86191       };
86192     } catch (...) {
86193       {
86194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86195       };
86196     }
86197   }
86198
86199   jresult = (void *)result;
86200   return jresult;
86201 }
86202
86203
86204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86205   void * jresult ;
86206   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86207   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86208
86209   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86210   {
86211     try {
86212       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86213     } catch (std::out_of_range& e) {
86214       {
86215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86216       };
86217     } catch (std::exception& e) {
86218       {
86219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86220       };
86221     } catch (Dali::DaliException e) {
86222       {
86223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86224       };
86225     } catch (...) {
86226       {
86227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86228       };
86229     }
86230   }
86231
86232   jresult = (void *)result;
86233   return jresult;
86234 }
86235
86236
86237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86238   void * jresult ;
86239   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86240   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86241
86242   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86243   {
86244     try {
86245       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86246     } catch (std::out_of_range& e) {
86247       {
86248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86249       };
86250     } catch (std::exception& e) {
86251       {
86252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86253       };
86254     } catch (Dali::DaliException e) {
86255       {
86256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86257       };
86258     } catch (...) {
86259       {
86260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86261       };
86262     }
86263   }
86264
86265   jresult = (void *)result;
86266   return jresult;
86267 }
86268
86269
86270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86271   void * jresult ;
86272   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86273   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86274
86275   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86276   {
86277     try {
86278       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86279     } catch (std::out_of_range& e) {
86280       {
86281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86282       };
86283     } catch (std::exception& e) {
86284       {
86285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86286       };
86287     } catch (Dali::DaliException e) {
86288       {
86289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86290       };
86291     } catch (...) {
86292       {
86293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86294       };
86295     }
86296   }
86297
86298   jresult = (void *)result;
86299   return jresult;
86300 }
86301
86302
86303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86304   void * jresult ;
86305   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86306   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86307
86308   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86309   {
86310     try {
86311       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86312     } catch (std::out_of_range& e) {
86313       {
86314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86315       };
86316     } catch (std::exception& e) {
86317       {
86318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86319       };
86320     } catch (Dali::DaliException e) {
86321       {
86322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86323       };
86324     } catch (...) {
86325       {
86326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86327       };
86328     }
86329   }
86330
86331   jresult = (void *)result;
86332   return jresult;
86333 }
86334
86335
86336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86337   void * jresult ;
86338   Dali::Toolkit::StyleManager *result = 0 ;
86339
86340   {
86341     try {
86342       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86343     } catch (std::out_of_range& e) {
86344       {
86345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86346       };
86347     } catch (std::exception& e) {
86348       {
86349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86350       };
86351     } catch (Dali::DaliException e) {
86352       {
86353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86354       };
86355     } catch (...) {
86356       {
86357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86358       };
86359     }
86360   }
86361
86362   jresult = (void *)result;
86363   return jresult;
86364 }
86365
86366
86367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86368   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86369
86370   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86371   {
86372     try {
86373       delete arg1;
86374     } catch (std::out_of_range& e) {
86375       {
86376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86377       };
86378     } catch (std::exception& e) {
86379       {
86380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86381       };
86382     } catch (Dali::DaliException e) {
86383       {
86384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86385       };
86386     } catch (...) {
86387       {
86388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86389       };
86390     }
86391   }
86392
86393 }
86394
86395
86396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86397   void * jresult ;
86398   Dali::Toolkit::StyleManager result;
86399
86400   {
86401     try {
86402       result = Dali::Toolkit::StyleManager::Get();
86403     } catch (std::out_of_range& e) {
86404       {
86405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86406       };
86407     } catch (std::exception& e) {
86408       {
86409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86410       };
86411     } catch (Dali::DaliException e) {
86412       {
86413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86414       };
86415     } catch (...) {
86416       {
86417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86418       };
86419     }
86420   }
86421
86422   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86423   return jresult;
86424 }
86425
86426
86427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86428   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86429   std::string *arg2 = 0 ;
86430
86431   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86432   if (!jarg2) {
86433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86434     return ;
86435   }
86436   std::string arg2_str(jarg2);
86437   arg2 = &arg2_str;
86438   {
86439     try {
86440       (arg1)->ApplyTheme((std::string const &)*arg2);
86441     } catch (std::out_of_range& e) {
86442       {
86443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86444       };
86445     } catch (std::exception& e) {
86446       {
86447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86448       };
86449     } catch (Dali::DaliException e) {
86450       {
86451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86452       };
86453     } catch (...) {
86454       {
86455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86456       };
86457     }
86458   }
86459
86460
86461   //argout typemap for const std::string&
86462
86463 }
86464
86465
86466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86467   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86468
86469   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86470   {
86471     try {
86472       (arg1)->ApplyDefaultTheme();
86473     } catch (std::out_of_range& e) {
86474       {
86475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86476       };
86477     } catch (std::exception& e) {
86478       {
86479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86480       };
86481     } catch (Dali::DaliException e) {
86482       {
86483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86484       };
86485     } catch (...) {
86486       {
86487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86488       };
86489     }
86490   }
86491
86492 }
86493
86494
86495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86496   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86497   std::string *arg2 = 0 ;
86498   Dali::Property::Value *arg3 = 0 ;
86499
86500   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86501   if (!jarg2) {
86502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86503     return ;
86504   }
86505   std::string arg2_str(jarg2);
86506   arg2 = &arg2_str;
86507   arg3 = (Dali::Property::Value *)jarg3;
86508   if (!arg3) {
86509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86510     return ;
86511   }
86512   {
86513     try {
86514       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86515     } catch (std::out_of_range& e) {
86516       {
86517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86518       };
86519     } catch (std::exception& e) {
86520       {
86521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86522       };
86523     } catch (Dali::DaliException e) {
86524       {
86525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86526       };
86527     } catch (...) {
86528       {
86529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86530       };
86531     }
86532   }
86533
86534
86535   //argout typemap for const std::string&
86536
86537 }
86538
86539
86540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86541   unsigned int jresult ;
86542   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86543   std::string *arg2 = 0 ;
86544   Dali::Property::Value *arg3 = 0 ;
86545   bool result;
86546
86547   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86548   if (!jarg2) {
86549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86550     return 0;
86551   }
86552   std::string arg2_str(jarg2);
86553   arg2 = &arg2_str;
86554   arg3 = (Dali::Property::Value *)jarg3;
86555   if (!arg3) {
86556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86557     return 0;
86558   }
86559   {
86560     try {
86561       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86562     } catch (std::out_of_range& e) {
86563       {
86564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86565       };
86566     } catch (std::exception& e) {
86567       {
86568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86569       };
86570     } catch (Dali::DaliException e) {
86571       {
86572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86573       };
86574     } catch (...) {
86575       {
86576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86577       };
86578     }
86579   }
86580
86581   jresult = result;
86582
86583   //argout typemap for const std::string&
86584
86585   return jresult;
86586 }
86587
86588
86589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86590   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86591   Dali::Toolkit::Control arg2 ;
86592   std::string *arg3 = 0 ;
86593   std::string *arg4 = 0 ;
86594   Dali::Toolkit::Control *argp2 ;
86595
86596   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86597   argp2 = (Dali::Toolkit::Control *)jarg2;
86598   if (!argp2) {
86599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86600     return ;
86601   }
86602   arg2 = *argp2;
86603   if (!jarg3) {
86604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86605     return ;
86606   }
86607   std::string arg3_str(jarg3);
86608   arg3 = &arg3_str;
86609   if (!jarg4) {
86610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86611     return ;
86612   }
86613   std::string arg4_str(jarg4);
86614   arg4 = &arg4_str;
86615   {
86616     try {
86617       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86618     } catch (std::out_of_range& e) {
86619       {
86620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86621       };
86622     } catch (std::exception& e) {
86623       {
86624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86625       };
86626     } catch (Dali::DaliException e) {
86627       {
86628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86629       };
86630     } catch (...) {
86631       {
86632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86633       };
86634     }
86635   }
86636
86637
86638   //argout typemap for const std::string&
86639
86640
86641   //argout typemap for const std::string&
86642
86643 }
86644
86645
86646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86647   void * jresult ;
86648   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86649   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86650
86651   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86652   {
86653     try {
86654       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86655     } catch (std::out_of_range& e) {
86656       {
86657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86658       };
86659     } catch (std::exception& e) {
86660       {
86661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86662       };
86663     } catch (Dali::DaliException e) {
86664       {
86665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86666       };
86667     } catch (...) {
86668       {
86669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86670       };
86671     }
86672   }
86673
86674   jresult = (void *)result;
86675   return jresult;
86676 }
86677
86678
86679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86680   int jresult ;
86681   int result;
86682
86683   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86684   jresult = (int)result;
86685   return jresult;
86686 }
86687
86688
86689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86690   int jresult ;
86691   int result;
86692
86693   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86694   jresult = (int)result;
86695   return jresult;
86696 }
86697
86698
86699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86700   int jresult ;
86701   int result;
86702
86703   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86704   jresult = (int)result;
86705   return jresult;
86706 }
86707
86708
86709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86710   int jresult ;
86711   int result;
86712
86713   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86714   jresult = (int)result;
86715   return jresult;
86716 }
86717
86718
86719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86720   int jresult ;
86721   int result;
86722
86723   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86724   jresult = (int)result;
86725   return jresult;
86726 }
86727
86728
86729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86730   int jresult ;
86731   int result;
86732
86733   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86734   jresult = (int)result;
86735   return jresult;
86736 }
86737
86738
86739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86740   int jresult ;
86741   int result;
86742
86743   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86744   jresult = (int)result;
86745   return jresult;
86746 }
86747
86748
86749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86750   int jresult ;
86751   int result;
86752
86753   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86754   jresult = (int)result;
86755   return jresult;
86756 }
86757
86758
86759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86760   int jresult ;
86761   int result;
86762
86763   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86764   jresult = (int)result;
86765   return jresult;
86766 }
86767
86768
86769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86770   int jresult ;
86771   int result;
86772
86773   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86774   jresult = (int)result;
86775   return jresult;
86776 }
86777
86778
86779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86780   int jresult ;
86781   int result;
86782
86783   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86784   jresult = (int)result;
86785   return jresult;
86786 }
86787
86788
86789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86790   int jresult ;
86791   int result;
86792
86793   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86794   jresult = (int)result;
86795   return jresult;
86796 }
86797
86798
86799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86800   int jresult ;
86801   int result;
86802
86803   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86804   jresult = (int)result;
86805   return jresult;
86806 }
86807
86808
86809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86810   int jresult ;
86811   int result;
86812
86813   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86814   jresult = (int)result;
86815   return jresult;
86816 }
86817
86818
86819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86820   int jresult ;
86821   int result;
86822
86823   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86824   jresult = (int)result;
86825   return jresult;
86826 }
86827
86828
86829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86830   void * jresult ;
86831   Dali::Toolkit::Slider::Property *result = 0 ;
86832
86833   {
86834     try {
86835       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86836     } catch (std::out_of_range& e) {
86837       {
86838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86839       };
86840     } catch (std::exception& e) {
86841       {
86842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86843       };
86844     } catch (Dali::DaliException e) {
86845       {
86846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86847       };
86848     } catch (...) {
86849       {
86850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86851       };
86852     }
86853   }
86854
86855   jresult = (void *)result;
86856   return jresult;
86857 }
86858
86859
86860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86861   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86862
86863   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86864   {
86865     try {
86866       delete arg1;
86867     } catch (std::out_of_range& e) {
86868       {
86869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86870       };
86871     } catch (std::exception& e) {
86872       {
86873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86874       };
86875     } catch (Dali::DaliException e) {
86876       {
86877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86878       };
86879     } catch (...) {
86880       {
86881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86882       };
86883     }
86884   }
86885
86886 }
86887
86888
86889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86890   void * jresult ;
86891   Dali::Toolkit::Slider result;
86892
86893   {
86894     try {
86895       result = Dali::Toolkit::Slider::New();
86896     } catch (std::out_of_range& e) {
86897       {
86898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86899       };
86900     } catch (std::exception& e) {
86901       {
86902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86903       };
86904     } catch (Dali::DaliException e) {
86905       {
86906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86907       };
86908     } catch (...) {
86909       {
86910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86911       };
86912     }
86913   }
86914
86915   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86916   return jresult;
86917 }
86918
86919
86920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86921   void * jresult ;
86922   Dali::Toolkit::Slider *result = 0 ;
86923
86924   {
86925     try {
86926       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86927     } catch (std::out_of_range& e) {
86928       {
86929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86930       };
86931     } catch (std::exception& e) {
86932       {
86933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86934       };
86935     } catch (Dali::DaliException e) {
86936       {
86937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86938       };
86939     } catch (...) {
86940       {
86941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86942       };
86943     }
86944   }
86945
86946   jresult = (void *)result;
86947   return jresult;
86948 }
86949
86950
86951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86952   void * jresult ;
86953   Dali::Toolkit::Slider *arg1 = 0 ;
86954   Dali::Toolkit::Slider *result = 0 ;
86955
86956   arg1 = (Dali::Toolkit::Slider *)jarg1;
86957   if (!arg1) {
86958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86959     return 0;
86960   }
86961   {
86962     try {
86963       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86964     } catch (std::out_of_range& e) {
86965       {
86966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86967       };
86968     } catch (std::exception& e) {
86969       {
86970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86971       };
86972     } catch (Dali::DaliException e) {
86973       {
86974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86975       };
86976     } catch (...) {
86977       {
86978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86979       };
86980     }
86981   }
86982
86983   jresult = (void *)result;
86984   return jresult;
86985 }
86986
86987
86988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86989   void * jresult ;
86990   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86991   Dali::Toolkit::Slider *arg2 = 0 ;
86992   Dali::Toolkit::Slider *result = 0 ;
86993
86994   arg1 = (Dali::Toolkit::Slider *)jarg1;
86995   arg2 = (Dali::Toolkit::Slider *)jarg2;
86996   if (!arg2) {
86997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86998     return 0;
86999   }
87000   {
87001     try {
87002       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87003     } catch (std::out_of_range& e) {
87004       {
87005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87006       };
87007     } catch (std::exception& e) {
87008       {
87009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87010       };
87011     } catch (Dali::DaliException e) {
87012       {
87013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87014       };
87015     } catch (...) {
87016       {
87017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87018       };
87019     }
87020   }
87021
87022   jresult = (void *)result;
87023   return jresult;
87024 }
87025
87026
87027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87028   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87029
87030   arg1 = (Dali::Toolkit::Slider *)jarg1;
87031   {
87032     try {
87033       delete arg1;
87034     } catch (std::out_of_range& e) {
87035       {
87036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87037       };
87038     } catch (std::exception& e) {
87039       {
87040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87041       };
87042     } catch (Dali::DaliException e) {
87043       {
87044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87045       };
87046     } catch (...) {
87047       {
87048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87049       };
87050     }
87051   }
87052
87053 }
87054
87055
87056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87057   void * jresult ;
87058   Dali::BaseHandle arg1 ;
87059   Dali::BaseHandle *argp1 ;
87060   Dali::Toolkit::Slider result;
87061
87062   argp1 = (Dali::BaseHandle *)jarg1;
87063   if (!argp1) {
87064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87065     return 0;
87066   }
87067   arg1 = *argp1;
87068   {
87069     try {
87070       result = Dali::Toolkit::Slider::DownCast(arg1);
87071     } catch (std::out_of_range& e) {
87072       {
87073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87074       };
87075     } catch (std::exception& e) {
87076       {
87077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87078       };
87079     } catch (Dali::DaliException e) {
87080       {
87081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87082       };
87083     } catch (...) {
87084       {
87085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87086       };
87087     }
87088   }
87089
87090   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87091   return jresult;
87092 }
87093
87094
87095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87096   void * jresult ;
87097   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87098   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87099
87100   arg1 = (Dali::Toolkit::Slider *)jarg1;
87101   {
87102     try {
87103       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87104     } catch (std::out_of_range& e) {
87105       {
87106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87107       };
87108     } catch (std::exception& e) {
87109       {
87110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87111       };
87112     } catch (Dali::DaliException e) {
87113       {
87114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87115       };
87116     } catch (...) {
87117       {
87118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87119       };
87120     }
87121   }
87122
87123   jresult = (void *)result;
87124   return jresult;
87125 }
87126
87127
87128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87129   void * jresult ;
87130   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87131   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87132
87133   arg1 = (Dali::Toolkit::Slider *)jarg1;
87134   {
87135     try {
87136       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87137     } catch (std::out_of_range& e) {
87138       {
87139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87140       };
87141     } catch (std::exception& e) {
87142       {
87143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87144       };
87145     } catch (Dali::DaliException e) {
87146       {
87147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87148       };
87149     } catch (...) {
87150       {
87151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87152       };
87153     }
87154   }
87155
87156   jresult = (void *)result;
87157   return jresult;
87158 }
87159
87160
87161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87162   void * jresult ;
87163   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87164   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87165
87166   arg1 = (Dali::Toolkit::Slider *)jarg1;
87167   {
87168     try {
87169       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87170     } catch (std::out_of_range& e) {
87171       {
87172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87173       };
87174     } catch (std::exception& e) {
87175       {
87176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87177       };
87178     } catch (Dali::DaliException e) {
87179       {
87180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87181       };
87182     } catch (...) {
87183       {
87184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87185       };
87186     }
87187   }
87188
87189   jresult = (void *)result;
87190   return jresult;
87191 }
87192
87193
87194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87195   int jresult ;
87196   int result;
87197
87198   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87199   jresult = (int)result;
87200   return jresult;
87201 }
87202
87203
87204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87205   int jresult ;
87206   int result;
87207
87208   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87209   jresult = (int)result;
87210   return jresult;
87211 }
87212
87213
87214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87215   int jresult ;
87216   int result;
87217
87218   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87219   jresult = (int)result;
87220   return jresult;
87221 }
87222
87223
87224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87225   int jresult ;
87226   int result;
87227
87228   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87229   jresult = (int)result;
87230   return jresult;
87231 }
87232
87233
87234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87235   int result;
87236
87237   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87238
87239   return result;
87240 }
87241
87242
87243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87244   void * jresult ;
87245   Dali::Toolkit::VideoView::Property *result = 0 ;
87246
87247   {
87248     try {
87249       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87250     } catch (std::out_of_range& e) {
87251       {
87252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87253       };
87254     } catch (std::exception& e) {
87255       {
87256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87257       };
87258     } catch (Dali::DaliException e) {
87259       {
87260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87261       };
87262     } catch (...) {
87263       {
87264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87265       };
87266     }
87267   }
87268
87269   jresult = (void *)result;
87270   return jresult;
87271 }
87272
87273
87274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87275   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87276
87277   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87278   {
87279     try {
87280       delete arg1;
87281     } catch (std::out_of_range& e) {
87282       {
87283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87284       };
87285     } catch (std::exception& e) {
87286       {
87287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87288       };
87289     } catch (Dali::DaliException e) {
87290       {
87291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87292       };
87293     } catch (...) {
87294       {
87295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87296       };
87297     }
87298   }
87299
87300 }
87301
87302
87303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87304   void * jresult ;
87305   Dali::Toolkit::VideoView result;
87306
87307   {
87308     try {
87309       result = Dali::Toolkit::VideoView::New();
87310     } catch (std::out_of_range& e) {
87311       {
87312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87313       };
87314     } catch (std::exception& e) {
87315       {
87316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87317       };
87318     } catch (Dali::DaliException e) {
87319       {
87320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87321       };
87322     } catch (...) {
87323       {
87324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87325       };
87326     }
87327   }
87328
87329   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87330   return jresult;
87331 }
87332
87333
87334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87335   void * jresult ;
87336   std::string *arg1 = 0 ;
87337   Dali::Toolkit::VideoView result;
87338
87339   if (!jarg1) {
87340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87341     return 0;
87342   }
87343   std::string arg1_str(jarg1);
87344   arg1 = &arg1_str;
87345   {
87346     try {
87347       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87348     } catch (std::out_of_range& e) {
87349       {
87350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87351       };
87352     } catch (std::exception& e) {
87353       {
87354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87355       };
87356     } catch (Dali::DaliException e) {
87357       {
87358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87359       };
87360     } catch (...) {
87361       {
87362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87363       };
87364     }
87365   }
87366
87367   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87368
87369   //argout typemap for const std::string&
87370
87371   return jresult;
87372 }
87373
87374
87375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87376   void * jresult ;
87377   Dali::Toolkit::VideoView *result = 0 ;
87378
87379   {
87380     try {
87381       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87382     } catch (std::out_of_range& e) {
87383       {
87384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87385       };
87386     } catch (std::exception& e) {
87387       {
87388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87389       };
87390     } catch (Dali::DaliException e) {
87391       {
87392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87393       };
87394     } catch (...) {
87395       {
87396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87397       };
87398     }
87399   }
87400
87401   jresult = (void *)result;
87402   return jresult;
87403 }
87404
87405
87406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87407   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87408
87409   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87410   {
87411     try {
87412       delete arg1;
87413     } catch (std::out_of_range& e) {
87414       {
87415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87416       };
87417     } catch (std::exception& e) {
87418       {
87419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87420       };
87421     } catch (Dali::DaliException e) {
87422       {
87423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87424       };
87425     } catch (...) {
87426       {
87427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87428       };
87429     }
87430   }
87431
87432 }
87433
87434
87435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87436   void * jresult ;
87437   Dali::Toolkit::VideoView *arg1 = 0 ;
87438   Dali::Toolkit::VideoView *result = 0 ;
87439
87440   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87441   if (!arg1) {
87442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87443     return 0;
87444   }
87445   {
87446     try {
87447       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87448     } catch (std::out_of_range& e) {
87449       {
87450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87451       };
87452     } catch (std::exception& e) {
87453       {
87454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87455       };
87456     } catch (Dali::DaliException e) {
87457       {
87458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87459       };
87460     } catch (...) {
87461       {
87462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87463       };
87464     }
87465   }
87466
87467   jresult = (void *)result;
87468   return jresult;
87469 }
87470
87471
87472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87473   void * jresult ;
87474   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87475   Dali::Toolkit::VideoView *arg2 = 0 ;
87476   Dali::Toolkit::VideoView *result = 0 ;
87477
87478   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87479   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87480   if (!arg2) {
87481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87482     return 0;
87483   }
87484   {
87485     try {
87486       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87487     } catch (std::out_of_range& e) {
87488       {
87489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87490       };
87491     } catch (std::exception& e) {
87492       {
87493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87494       };
87495     } catch (Dali::DaliException e) {
87496       {
87497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87498       };
87499     } catch (...) {
87500       {
87501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87502       };
87503     }
87504   }
87505
87506   jresult = (void *)result;
87507   return jresult;
87508 }
87509
87510
87511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87512   void * jresult ;
87513   Dali::BaseHandle arg1 ;
87514   Dali::BaseHandle *argp1 ;
87515   Dali::Toolkit::VideoView result;
87516
87517   argp1 = (Dali::BaseHandle *)jarg1;
87518   if (!argp1) {
87519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87520     return 0;
87521   }
87522   arg1 = *argp1;
87523   {
87524     try {
87525       result = Dali::Toolkit::VideoView::DownCast(arg1);
87526     } catch (std::out_of_range& e) {
87527       {
87528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87529       };
87530     } catch (std::exception& e) {
87531       {
87532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87533       };
87534     } catch (Dali::DaliException e) {
87535       {
87536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87537       };
87538     } catch (...) {
87539       {
87540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87541       };
87542     }
87543   }
87544
87545   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87546   return jresult;
87547 }
87548
87549
87550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87551   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87552
87553   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87554   {
87555     try {
87556       (arg1)->Play();
87557     } catch (std::out_of_range& e) {
87558       {
87559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87560       };
87561     } catch (std::exception& e) {
87562       {
87563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87564       };
87565     } catch (Dali::DaliException e) {
87566       {
87567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87568       };
87569     } catch (...) {
87570       {
87571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87572       };
87573     }
87574   }
87575
87576 }
87577
87578
87579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87580   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87581
87582   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87583   {
87584     try {
87585       (arg1)->Pause();
87586     } catch (std::out_of_range& e) {
87587       {
87588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87589       };
87590     } catch (std::exception& e) {
87591       {
87592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87593       };
87594     } catch (Dali::DaliException e) {
87595       {
87596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87597       };
87598     } catch (...) {
87599       {
87600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87601       };
87602     }
87603   }
87604
87605 }
87606
87607
87608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87609   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87610
87611   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87612   {
87613     try {
87614       (arg1)->Stop();
87615     } catch (std::out_of_range& e) {
87616       {
87617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87618       };
87619     } catch (std::exception& e) {
87620       {
87621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87622       };
87623     } catch (Dali::DaliException e) {
87624       {
87625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87626       };
87627     } catch (...) {
87628       {
87629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87630       };
87631     }
87632   }
87633
87634 }
87635
87636
87637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87638   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87639   int arg2 ;
87640
87641   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87642   arg2 = (int)jarg2;
87643   {
87644     try {
87645       (arg1)->Forward(arg2);
87646     } catch (std::out_of_range& e) {
87647       {
87648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87649       };
87650     } catch (std::exception& e) {
87651       {
87652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87653       };
87654     } catch (Dali::DaliException e) {
87655       {
87656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87657       };
87658     } catch (...) {
87659       {
87660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87661       };
87662     }
87663   }
87664
87665 }
87666
87667
87668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87669   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87670   int arg2 ;
87671
87672   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87673   arg2 = (int)jarg2;
87674   {
87675     try {
87676       (arg1)->Backward(arg2);
87677     } catch (std::out_of_range& e) {
87678       {
87679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87680       };
87681     } catch (std::exception& e) {
87682       {
87683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87684       };
87685     } catch (Dali::DaliException e) {
87686       {
87687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87688       };
87689     } catch (...) {
87690       {
87691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87692       };
87693     }
87694   }
87695
87696 }
87697
87698
87699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87700   void * jresult ;
87701   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87702   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87703
87704   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87705   {
87706     try {
87707       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87708     } catch (std::out_of_range& e) {
87709       {
87710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87711       };
87712     } catch (std::exception& e) {
87713       {
87714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87715       };
87716     } catch (Dali::DaliException e) {
87717       {
87718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87719       };
87720     } catch (...) {
87721       {
87722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87723       };
87724     }
87725   }
87726
87727   jresult = (void *)result;
87728   return jresult;
87729 }
87730
87731
87732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87733   int jresult ;
87734   int result;
87735
87736   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87737   jresult = (int)result;
87738   return jresult;
87739 }
87740
87741
87742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87743   int jresult ;
87744   int result;
87745
87746   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87747   jresult = (int)result;
87748   return jresult;
87749 }
87750
87751
87752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87753   int jresult ;
87754   int result;
87755
87756   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87757   jresult = (int)result;
87758   return jresult;
87759 }
87760
87761
87762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87763   int jresult ;
87764   int result;
87765
87766   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87767   jresult = (int)result;
87768   return jresult;
87769 }
87770
87771
87772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87773   int jresult ;
87774   int result;
87775
87776   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87777   jresult = (int)result;
87778   return jresult;
87779 }
87780
87781
87782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87783   int jresult ;
87784   int result;
87785
87786   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87787   jresult = (int)result;
87788   return jresult;
87789 }
87790
87791
87792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87793   int jresult ;
87794   int result;
87795
87796   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87797   jresult = (int)result;
87798   return jresult;
87799 }
87800
87801
87802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87803   int jresult ;
87804   int result;
87805
87806   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87807   jresult = (int)result;
87808   return jresult;
87809 }
87810
87811
87812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87813   int jresult ;
87814   int result;
87815
87816   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87817   jresult = (int)result;
87818   return jresult;
87819 }
87820
87821
87822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87823   int jresult ;
87824   int result;
87825
87826   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87827   jresult = (int)result;
87828   return jresult;
87829 }
87830
87831
87832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87833   int jresult ;
87834   int result;
87835
87836   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87837   jresult = (int)result;
87838   return jresult;
87839 }
87840
87841
87842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87843   int jresult ;
87844   int result;
87845
87846   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87847   jresult = (int)result;
87848   return jresult;
87849 }
87850
87851
87852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87853   int jresult ;
87854   int result;
87855
87856   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87857   jresult = (int)result;
87858   return jresult;
87859 }
87860
87861
87862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87863   int jresult ;
87864   int result;
87865
87866   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87867   jresult = (int)result;
87868   return jresult;
87869 }
87870
87871
87872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87873   int jresult ;
87874   int result;
87875
87876   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87877   jresult = (int)result;
87878   return jresult;
87879 }
87880
87881
87882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87883   int jresult ;
87884   int result;
87885
87886   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87887   jresult = (int)result;
87888   return jresult;
87889 }
87890
87891
87892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87893   int jresult ;
87894   int result;
87895
87896   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87897   jresult = (int)result;
87898   return jresult;
87899 }
87900
87901
87902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87903   int jresult ;
87904   int result;
87905
87906   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87907   jresult = (int)result;
87908   return jresult;
87909 }
87910
87911
87912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87913   int jresult ;
87914   int result;
87915
87916   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87917   jresult = (int)result;
87918   return jresult;
87919 }
87920
87921
87922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87923   int jresult ;
87924   int result;
87925
87926   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87927   jresult = (int)result;
87928   return jresult;
87929 }
87930
87931
87932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87933   int jresult ;
87934   int result;
87935
87936   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87937   jresult = (int)result;
87938   return jresult;
87939 }
87940
87941
87942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87943   void * jresult ;
87944   Dali::Toolkit::Popup::Property *result = 0 ;
87945
87946   {
87947     try {
87948       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87949     } catch (std::out_of_range& e) {
87950       {
87951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87952       };
87953     } catch (std::exception& e) {
87954       {
87955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87956       };
87957     } catch (Dali::DaliException e) {
87958       {
87959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87960       };
87961     } catch (...) {
87962       {
87963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87964       };
87965     }
87966   }
87967
87968   jresult = (void *)result;
87969   return jresult;
87970 }
87971
87972
87973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87974   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87975
87976   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87977   {
87978     try {
87979       delete arg1;
87980     } catch (std::out_of_range& e) {
87981       {
87982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87983       };
87984     } catch (std::exception& e) {
87985       {
87986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87987       };
87988     } catch (Dali::DaliException e) {
87989       {
87990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87991       };
87992     } catch (...) {
87993       {
87994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87995       };
87996     }
87997   }
87998
87999 }
88000
88001
88002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88003   void * jresult ;
88004   Dali::Toolkit::Popup *result = 0 ;
88005
88006   {
88007     try {
88008       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88009     } catch (std::out_of_range& e) {
88010       {
88011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88012       };
88013     } catch (std::exception& e) {
88014       {
88015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88016       };
88017     } catch (Dali::DaliException e) {
88018       {
88019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88020       };
88021     } catch (...) {
88022       {
88023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88024       };
88025     }
88026   }
88027
88028   jresult = (void *)result;
88029   return jresult;
88030 }
88031
88032
88033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88034   void * jresult ;
88035   Dali::Toolkit::Popup result;
88036
88037   {
88038     try {
88039       result = Dali::Toolkit::Popup::New();
88040     } catch (std::out_of_range& e) {
88041       {
88042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88043       };
88044     } catch (std::exception& e) {
88045       {
88046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88047       };
88048     } catch (Dali::DaliException e) {
88049       {
88050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88051       };
88052     } catch (...) {
88053       {
88054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88055       };
88056     }
88057   }
88058
88059   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88060   return jresult;
88061 }
88062
88063
88064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88065   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88066
88067   arg1 = (Dali::Toolkit::Popup *)jarg1;
88068   {
88069     try {
88070       delete arg1;
88071     } catch (std::out_of_range& e) {
88072       {
88073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88074       };
88075     } catch (std::exception& e) {
88076       {
88077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88078       };
88079     } catch (Dali::DaliException e) {
88080       {
88081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88082       };
88083     } catch (...) {
88084       {
88085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88086       };
88087     }
88088   }
88089
88090 }
88091
88092
88093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88094   void * jresult ;
88095   Dali::Toolkit::Popup *arg1 = 0 ;
88096   Dali::Toolkit::Popup *result = 0 ;
88097
88098   arg1 = (Dali::Toolkit::Popup *)jarg1;
88099   if (!arg1) {
88100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88101     return 0;
88102   }
88103   {
88104     try {
88105       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88106     } catch (std::out_of_range& e) {
88107       {
88108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88109       };
88110     } catch (std::exception& e) {
88111       {
88112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88113       };
88114     } catch (Dali::DaliException e) {
88115       {
88116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88117       };
88118     } catch (...) {
88119       {
88120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88121       };
88122     }
88123   }
88124
88125   jresult = (void *)result;
88126   return jresult;
88127 }
88128
88129
88130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88131   void * jresult ;
88132   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88133   Dali::Toolkit::Popup *arg2 = 0 ;
88134   Dali::Toolkit::Popup *result = 0 ;
88135
88136   arg1 = (Dali::Toolkit::Popup *)jarg1;
88137   arg2 = (Dali::Toolkit::Popup *)jarg2;
88138   if (!arg2) {
88139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88140     return 0;
88141   }
88142   {
88143     try {
88144       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88145     } catch (std::out_of_range& e) {
88146       {
88147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88148       };
88149     } catch (std::exception& e) {
88150       {
88151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88152       };
88153     } catch (Dali::DaliException e) {
88154       {
88155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88156       };
88157     } catch (...) {
88158       {
88159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88160       };
88161     }
88162   }
88163
88164   jresult = (void *)result;
88165   return jresult;
88166 }
88167
88168
88169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88170   void * jresult ;
88171   Dali::BaseHandle arg1 ;
88172   Dali::BaseHandle *argp1 ;
88173   Dali::Toolkit::Popup result;
88174
88175   argp1 = (Dali::BaseHandle *)jarg1;
88176   if (!argp1) {
88177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88178     return 0;
88179   }
88180   arg1 = *argp1;
88181   {
88182     try {
88183       result = Dali::Toolkit::Popup::DownCast(arg1);
88184     } catch (std::out_of_range& e) {
88185       {
88186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88187       };
88188     } catch (std::exception& e) {
88189       {
88190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88191       };
88192     } catch (Dali::DaliException e) {
88193       {
88194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88195       };
88196     } catch (...) {
88197       {
88198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88199       };
88200     }
88201   }
88202
88203   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88204   return jresult;
88205 }
88206
88207
88208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88209   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88210   Dali::Actor arg2 ;
88211   Dali::Actor *argp2 ;
88212
88213   arg1 = (Dali::Toolkit::Popup *)jarg1;
88214   argp2 = (Dali::Actor *)jarg2;
88215   if (!argp2) {
88216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88217     return ;
88218   }
88219   arg2 = *argp2;
88220   {
88221     try {
88222       (arg1)->SetTitle(arg2);
88223     } catch (std::out_of_range& e) {
88224       {
88225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88226       };
88227     } catch (std::exception& e) {
88228       {
88229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88230       };
88231     } catch (Dali::DaliException e) {
88232       {
88233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88234       };
88235     } catch (...) {
88236       {
88237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88238       };
88239     }
88240   }
88241
88242 }
88243
88244
88245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88246   void * jresult ;
88247   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88248   Dali::Actor result;
88249
88250   arg1 = (Dali::Toolkit::Popup *)jarg1;
88251   {
88252     try {
88253       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88254     } catch (std::out_of_range& e) {
88255       {
88256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88257       };
88258     } catch (std::exception& e) {
88259       {
88260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88261       };
88262     } catch (Dali::DaliException e) {
88263       {
88264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88265       };
88266     } catch (...) {
88267       {
88268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88269       };
88270     }
88271   }
88272
88273   jresult = new Dali::Actor((const Dali::Actor &)result);
88274   return jresult;
88275 }
88276
88277
88278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88279   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88280   Dali::Actor arg2 ;
88281   Dali::Actor *argp2 ;
88282
88283   arg1 = (Dali::Toolkit::Popup *)jarg1;
88284   argp2 = (Dali::Actor *)jarg2;
88285   if (!argp2) {
88286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88287     return ;
88288   }
88289   arg2 = *argp2;
88290   {
88291     try {
88292       (arg1)->SetContent(arg2);
88293     } catch (std::out_of_range& e) {
88294       {
88295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88296       };
88297     } catch (std::exception& e) {
88298       {
88299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88300       };
88301     } catch (Dali::DaliException e) {
88302       {
88303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88304       };
88305     } catch (...) {
88306       {
88307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88308       };
88309     }
88310   }
88311
88312 }
88313
88314
88315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88316   void * jresult ;
88317   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88318   Dali::Actor result;
88319
88320   arg1 = (Dali::Toolkit::Popup *)jarg1;
88321   {
88322     try {
88323       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88324     } catch (std::out_of_range& e) {
88325       {
88326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88327       };
88328     } catch (std::exception& e) {
88329       {
88330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88331       };
88332     } catch (Dali::DaliException e) {
88333       {
88334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88335       };
88336     } catch (...) {
88337       {
88338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88339       };
88340     }
88341   }
88342
88343   jresult = new Dali::Actor((const Dali::Actor &)result);
88344   return jresult;
88345 }
88346
88347
88348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88349   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88350   Dali::Actor arg2 ;
88351   Dali::Actor *argp2 ;
88352
88353   arg1 = (Dali::Toolkit::Popup *)jarg1;
88354   argp2 = (Dali::Actor *)jarg2;
88355   if (!argp2) {
88356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88357     return ;
88358   }
88359   arg2 = *argp2;
88360   {
88361     try {
88362       (arg1)->SetFooter(arg2);
88363     } catch (std::out_of_range& e) {
88364       {
88365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88366       };
88367     } catch (std::exception& e) {
88368       {
88369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88370       };
88371     } catch (Dali::DaliException e) {
88372       {
88373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88374       };
88375     } catch (...) {
88376       {
88377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88378       };
88379     }
88380   }
88381
88382 }
88383
88384
88385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88386   void * jresult ;
88387   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88388   Dali::Actor result;
88389
88390   arg1 = (Dali::Toolkit::Popup *)jarg1;
88391   {
88392     try {
88393       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88394     } catch (std::out_of_range& e) {
88395       {
88396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88397       };
88398     } catch (std::exception& e) {
88399       {
88400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88401       };
88402     } catch (Dali::DaliException e) {
88403       {
88404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88405       };
88406     } catch (...) {
88407       {
88408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88409       };
88410     }
88411   }
88412
88413   jresult = new Dali::Actor((const Dali::Actor &)result);
88414   return jresult;
88415 }
88416
88417
88418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88419   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88420   Dali::Toolkit::Popup::DisplayState arg2 ;
88421
88422   arg1 = (Dali::Toolkit::Popup *)jarg1;
88423   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88424   {
88425     try {
88426       (arg1)->SetDisplayState(arg2);
88427     } catch (std::out_of_range& e) {
88428       {
88429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88430       };
88431     } catch (std::exception& e) {
88432       {
88433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88434       };
88435     } catch (Dali::DaliException e) {
88436       {
88437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88438       };
88439     } catch (...) {
88440       {
88441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88442       };
88443     }
88444   }
88445
88446 }
88447
88448
88449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88450   int jresult ;
88451   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88452   Dali::Toolkit::Popup::DisplayState result;
88453
88454   arg1 = (Dali::Toolkit::Popup *)jarg1;
88455   {
88456     try {
88457       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88458     } catch (std::out_of_range& e) {
88459       {
88460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88461       };
88462     } catch (std::exception& e) {
88463       {
88464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88465       };
88466     } catch (Dali::DaliException e) {
88467       {
88468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88469       };
88470     } catch (...) {
88471       {
88472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88473       };
88474     }
88475   }
88476
88477   jresult = (int)result;
88478   return jresult;
88479 }
88480
88481
88482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88483   void * jresult ;
88484   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88485   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88486
88487   arg1 = (Dali::Toolkit::Popup *)jarg1;
88488   {
88489     try {
88490       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88491     } catch (std::out_of_range& e) {
88492       {
88493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88494       };
88495     } catch (std::exception& e) {
88496       {
88497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88498       };
88499     } catch (Dali::DaliException e) {
88500       {
88501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88502       };
88503     } catch (...) {
88504       {
88505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88506       };
88507     }
88508   }
88509
88510   jresult = (void *)result;
88511   return jresult;
88512 }
88513
88514
88515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88516   void * jresult ;
88517   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88518   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88519
88520   arg1 = (Dali::Toolkit::Popup *)jarg1;
88521   {
88522     try {
88523       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88524     } catch (std::out_of_range& e) {
88525       {
88526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88527       };
88528     } catch (std::exception& e) {
88529       {
88530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88531       };
88532     } catch (Dali::DaliException e) {
88533       {
88534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88535       };
88536     } catch (...) {
88537       {
88538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88539       };
88540     }
88541   }
88542
88543   jresult = (void *)result;
88544   return jresult;
88545 }
88546
88547
88548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88549   void * jresult ;
88550   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88551   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88552
88553   arg1 = (Dali::Toolkit::Popup *)jarg1;
88554   {
88555     try {
88556       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88557     } catch (std::out_of_range& e) {
88558       {
88559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88560       };
88561     } catch (std::exception& e) {
88562       {
88563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88564       };
88565     } catch (Dali::DaliException e) {
88566       {
88567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88568       };
88569     } catch (...) {
88570       {
88571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88572       };
88573     }
88574   }
88575
88576   jresult = (void *)result;
88577   return jresult;
88578 }
88579
88580
88581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88582   void * jresult ;
88583   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88584   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88585
88586   arg1 = (Dali::Toolkit::Popup *)jarg1;
88587   {
88588     try {
88589       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88590     } catch (std::out_of_range& e) {
88591       {
88592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88593       };
88594     } catch (std::exception& e) {
88595       {
88596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88597       };
88598     } catch (Dali::DaliException e) {
88599       {
88600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88601       };
88602     } catch (...) {
88603       {
88604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88605       };
88606     }
88607   }
88608
88609   jresult = (void *)result;
88610   return jresult;
88611 }
88612
88613
88614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88615   void * jresult ;
88616   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88617   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88618
88619   arg1 = (Dali::Toolkit::Popup *)jarg1;
88620   {
88621     try {
88622       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88623     } catch (std::out_of_range& e) {
88624       {
88625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88626       };
88627     } catch (std::exception& e) {
88628       {
88629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88630       };
88631     } catch (Dali::DaliException e) {
88632       {
88633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88634       };
88635     } catch (...) {
88636       {
88637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88638       };
88639     }
88640   }
88641
88642   jresult = (void *)result;
88643   return jresult;
88644 }
88645
88646
88647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88648   int jresult ;
88649   int result;
88650
88651   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88652   jresult = (int)result;
88653   return jresult;
88654 }
88655
88656
88657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88658   int jresult ;
88659   int result;
88660
88661   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88662   jresult = (int)result;
88663   return jresult;
88664 }
88665
88666
88667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88668   int jresult ;
88669   int result;
88670
88671   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88672   jresult = (int)result;
88673   return jresult;
88674 }
88675
88676
88677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88678   int jresult ;
88679   int result;
88680
88681   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88682   jresult = (int)result;
88683   return jresult;
88684 }
88685
88686
88687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88688   int jresult ;
88689   int result;
88690
88691   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88692   jresult = (int)result;
88693   return jresult;
88694 }
88695
88696
88697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88698   int jresult ;
88699   int result;
88700
88701   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88702   jresult = (int)result;
88703   return jresult;
88704 }
88705
88706
88707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88708   int jresult ;
88709   int result;
88710
88711   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88712   jresult = (int)result;
88713   return jresult;
88714 }
88715
88716
88717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88718   int jresult ;
88719   int result;
88720
88721   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88722   jresult = (int)result;
88723   return jresult;
88724 }
88725
88726
88727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88728   int jresult ;
88729   int result;
88730
88731   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88732   jresult = (int)result;
88733   return jresult;
88734 }
88735
88736
88737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88738   void * jresult ;
88739   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88740
88741   {
88742     try {
88743       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88744     } catch (std::out_of_range& e) {
88745       {
88746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88747       };
88748     } catch (std::exception& e) {
88749       {
88750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88751       };
88752     } catch (Dali::DaliException e) {
88753       {
88754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88755       };
88756     } catch (...) {
88757       {
88758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88759       };
88760     }
88761   }
88762
88763   jresult = (void *)result;
88764   return jresult;
88765 }
88766
88767
88768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88769   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88770
88771   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88772   {
88773     try {
88774       delete arg1;
88775     } catch (std::out_of_range& e) {
88776       {
88777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88778       };
88779     } catch (std::exception& e) {
88780       {
88781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88782       };
88783     } catch (Dali::DaliException e) {
88784       {
88785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88786       };
88787     } catch (...) {
88788       {
88789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88790       };
88791     }
88792   }
88793
88794 }
88795
88796
88797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88798   void * jresult ;
88799   Dali::Toolkit::ProgressBar result;
88800
88801   {
88802     try {
88803       result = Dali::Toolkit::ProgressBar::New();
88804     } catch (std::out_of_range& e) {
88805       {
88806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88807       };
88808     } catch (std::exception& e) {
88809       {
88810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88811       };
88812     } catch (Dali::DaliException e) {
88813       {
88814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88815       };
88816     } catch (...) {
88817       {
88818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88819       };
88820     }
88821   }
88822
88823   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88824   return jresult;
88825 }
88826
88827
88828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88829   void * jresult ;
88830   Dali::Toolkit::ProgressBar *result = 0 ;
88831
88832   {
88833     try {
88834       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88835     } catch (std::out_of_range& e) {
88836       {
88837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88838       };
88839     } catch (std::exception& e) {
88840       {
88841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88842       };
88843     } catch (Dali::DaliException e) {
88844       {
88845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88846       };
88847     } catch (...) {
88848       {
88849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88850       };
88851     }
88852   }
88853
88854   jresult = (void *)result;
88855   return jresult;
88856 }
88857
88858
88859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88860   void * jresult ;
88861   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88862   Dali::Toolkit::ProgressBar *result = 0 ;
88863
88864   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88865   if (!arg1) {
88866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88867     return 0;
88868   }
88869   {
88870     try {
88871       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88872     } catch (std::out_of_range& e) {
88873       {
88874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88875       };
88876     } catch (std::exception& e) {
88877       {
88878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88879       };
88880     } catch (Dali::DaliException e) {
88881       {
88882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88883       };
88884     } catch (...) {
88885       {
88886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88887       };
88888     }
88889   }
88890
88891   jresult = (void *)result;
88892   return jresult;
88893 }
88894
88895
88896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88897   void * jresult ;
88898   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88899   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88900   Dali::Toolkit::ProgressBar *result = 0 ;
88901
88902   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88903   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88904   if (!arg2) {
88905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88906     return 0;
88907   }
88908   {
88909     try {
88910       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88911     } catch (std::out_of_range& e) {
88912       {
88913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88914       };
88915     } catch (std::exception& e) {
88916       {
88917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88918       };
88919     } catch (Dali::DaliException e) {
88920       {
88921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88922       };
88923     } catch (...) {
88924       {
88925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88926       };
88927     }
88928   }
88929
88930   jresult = (void *)result;
88931   return jresult;
88932 }
88933
88934
88935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88936   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88937
88938   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88939   {
88940     try {
88941       delete arg1;
88942     } catch (std::out_of_range& e) {
88943       {
88944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88945       };
88946     } catch (std::exception& e) {
88947       {
88948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88949       };
88950     } catch (Dali::DaliException e) {
88951       {
88952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88953       };
88954     } catch (...) {
88955       {
88956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88957       };
88958     }
88959   }
88960
88961 }
88962
88963
88964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88965   void * jresult ;
88966   Dali::BaseHandle arg1 ;
88967   Dali::BaseHandle *argp1 ;
88968   Dali::Toolkit::ProgressBar result;
88969
88970   argp1 = (Dali::BaseHandle *)jarg1;
88971   if (!argp1) {
88972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88973     return 0;
88974   }
88975   arg1 = *argp1;
88976   {
88977     try {
88978       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88979     } catch (std::out_of_range& e) {
88980       {
88981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88982       };
88983     } catch (std::exception& e) {
88984       {
88985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88986       };
88987     } catch (Dali::DaliException e) {
88988       {
88989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88990       };
88991     } catch (...) {
88992       {
88993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88994       };
88995     }
88996   }
88997
88998   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88999   return jresult;
89000 }
89001
89002
89003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89004   void * jresult ;
89005   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89006   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89007
89008   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89009   {
89010     try {
89011       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89012     } catch (std::out_of_range& e) {
89013       {
89014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89015       };
89016     } catch (std::exception& e) {
89017       {
89018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89019       };
89020     } catch (Dali::DaliException e) {
89021       {
89022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89023       };
89024     } catch (...) {
89025       {
89026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89027       };
89028     }
89029   }
89030
89031   jresult = (void *)result;
89032   return jresult;
89033 }
89034
89035
89036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89037   void * jresult ;
89038   Dali::Toolkit::GaussianBlurView *result = 0 ;
89039
89040   {
89041     try {
89042       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89043     } catch (std::out_of_range& e) {
89044       {
89045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89046       };
89047     } catch (std::exception& e) {
89048       {
89049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89050       };
89051     } catch (Dali::DaliException e) {
89052       {
89053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89054       };
89055     } catch (...) {
89056       {
89057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89058       };
89059     }
89060   }
89061
89062   jresult = (void *)result;
89063   return jresult;
89064 }
89065
89066
89067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89068   void * jresult ;
89069   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89070   Dali::Toolkit::GaussianBlurView *result = 0 ;
89071
89072   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89073   if (!arg1) {
89074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89075     return 0;
89076   }
89077   {
89078     try {
89079       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89080     } catch (std::out_of_range& e) {
89081       {
89082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89083       };
89084     } catch (std::exception& e) {
89085       {
89086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89087       };
89088     } catch (Dali::DaliException e) {
89089       {
89090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89091       };
89092     } catch (...) {
89093       {
89094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89095       };
89096     }
89097   }
89098
89099   jresult = (void *)result;
89100   return jresult;
89101 }
89102
89103
89104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89105   void * jresult ;
89106   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89107   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89108   Dali::Toolkit::GaussianBlurView *result = 0 ;
89109
89110   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89111   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89112   if (!arg2) {
89113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89114     return 0;
89115   }
89116   {
89117     try {
89118       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89119     } catch (std::out_of_range& e) {
89120       {
89121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89122       };
89123     } catch (std::exception& e) {
89124       {
89125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89126       };
89127     } catch (Dali::DaliException e) {
89128       {
89129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89130       };
89131     } catch (...) {
89132       {
89133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89134       };
89135     }
89136   }
89137
89138   jresult = (void *)result;
89139   return jresult;
89140 }
89141
89142
89143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89144   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89145
89146   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89147   {
89148     try {
89149       delete arg1;
89150     } catch (std::out_of_range& e) {
89151       {
89152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89153       };
89154     } catch (std::exception& e) {
89155       {
89156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89157       };
89158     } catch (Dali::DaliException e) {
89159       {
89160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89161       };
89162     } catch (...) {
89163       {
89164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89165       };
89166     }
89167   }
89168
89169 }
89170
89171
89172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89173   void * jresult ;
89174   Dali::BaseHandle arg1 ;
89175   Dali::BaseHandle *argp1 ;
89176   Dali::Toolkit::GaussianBlurView result;
89177
89178   argp1 = (Dali::BaseHandle *)jarg1;
89179   if (!argp1) {
89180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89181     return 0;
89182   }
89183   arg1 = *argp1;
89184   {
89185     try {
89186       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89187     } catch (std::out_of_range& e) {
89188       {
89189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89190       };
89191     } catch (std::exception& e) {
89192       {
89193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89194       };
89195     } catch (Dali::DaliException e) {
89196       {
89197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89198       };
89199     } catch (...) {
89200       {
89201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89202       };
89203     }
89204   }
89205
89206   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89207   return jresult;
89208 }
89209
89210
89211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89212   void * jresult ;
89213   Dali::Toolkit::GaussianBlurView result;
89214
89215   {
89216     try {
89217       result = Dali::Toolkit::GaussianBlurView::New();
89218     } catch (std::out_of_range& e) {
89219       {
89220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89221       };
89222     } catch (std::exception& e) {
89223       {
89224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89225       };
89226     } catch (Dali::DaliException e) {
89227       {
89228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89229       };
89230     } catch (...) {
89231       {
89232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89233       };
89234     }
89235   }
89236
89237   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89238   return jresult;
89239 }
89240
89241
89242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89243   void * jresult ;
89244   unsigned int arg1 ;
89245   float arg2 ;
89246   Dali::Pixel::Format arg3 ;
89247   float arg4 ;
89248   float arg5 ;
89249   bool arg6 ;
89250   Dali::Toolkit::GaussianBlurView result;
89251
89252   arg1 = (unsigned int)jarg1;
89253   arg2 = (float)jarg2;
89254   arg3 = (Dali::Pixel::Format)jarg3;
89255   arg4 = (float)jarg4;
89256   arg5 = (float)jarg5;
89257   arg6 = jarg6 ? true : false;
89258   {
89259     try {
89260       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89261     } catch (std::out_of_range& e) {
89262       {
89263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89264       };
89265     } catch (std::exception& e) {
89266       {
89267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89268       };
89269     } catch (Dali::DaliException e) {
89270       {
89271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89272       };
89273     } catch (...) {
89274       {
89275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89276       };
89277     }
89278   }
89279
89280   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89281   return jresult;
89282 }
89283
89284
89285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89286   void * jresult ;
89287   unsigned int arg1 ;
89288   float arg2 ;
89289   Dali::Pixel::Format arg3 ;
89290   float arg4 ;
89291   float arg5 ;
89292   Dali::Toolkit::GaussianBlurView result;
89293
89294   arg1 = (unsigned int)jarg1;
89295   arg2 = (float)jarg2;
89296   arg3 = (Dali::Pixel::Format)jarg3;
89297   arg4 = (float)jarg4;
89298   arg5 = (float)jarg5;
89299   {
89300     try {
89301       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89302     } catch (std::out_of_range& e) {
89303       {
89304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89305       };
89306     } catch (std::exception& e) {
89307       {
89308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89309       };
89310     } catch (Dali::DaliException e) {
89311       {
89312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89313       };
89314     } catch (...) {
89315       {
89316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89317       };
89318     }
89319   }
89320
89321   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89322   return jresult;
89323 }
89324
89325
89326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89327   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89328   Dali::Actor arg2 ;
89329   Dali::Actor *argp2 ;
89330
89331   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89332   argp2 = (Dali::Actor *)jarg2;
89333   if (!argp2) {
89334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89335     return ;
89336   }
89337   arg2 = *argp2;
89338   {
89339     try {
89340       (arg1)->Add(arg2);
89341     } catch (std::out_of_range& e) {
89342       {
89343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89344       };
89345     } catch (std::exception& e) {
89346       {
89347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89348       };
89349     } catch (Dali::DaliException e) {
89350       {
89351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89352       };
89353     } catch (...) {
89354       {
89355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89356       };
89357     }
89358   }
89359
89360 }
89361
89362
89363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89364   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89365   Dali::Actor arg2 ;
89366   Dali::Actor *argp2 ;
89367
89368   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89369   argp2 = (Dali::Actor *)jarg2;
89370   if (!argp2) {
89371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89372     return ;
89373   }
89374   arg2 = *argp2;
89375   {
89376     try {
89377       (arg1)->Remove(arg2);
89378     } catch (std::out_of_range& e) {
89379       {
89380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89381       };
89382     } catch (std::exception& e) {
89383       {
89384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89385       };
89386     } catch (Dali::DaliException e) {
89387       {
89388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89389       };
89390     } catch (...) {
89391       {
89392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89393       };
89394     }
89395   }
89396
89397 }
89398
89399
89400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89401   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89402
89403   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89404   {
89405     try {
89406       (arg1)->Activate();
89407     } catch (std::out_of_range& e) {
89408       {
89409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89410       };
89411     } catch (std::exception& e) {
89412       {
89413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89414       };
89415     } catch (Dali::DaliException e) {
89416       {
89417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89418       };
89419     } catch (...) {
89420       {
89421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89422       };
89423     }
89424   }
89425
89426 }
89427
89428
89429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89430   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89431
89432   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89433   {
89434     try {
89435       (arg1)->ActivateOnce();
89436     } catch (std::out_of_range& e) {
89437       {
89438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89439       };
89440     } catch (std::exception& e) {
89441       {
89442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89443       };
89444     } catch (Dali::DaliException e) {
89445       {
89446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89447       };
89448     } catch (...) {
89449       {
89450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89451       };
89452     }
89453   }
89454
89455 }
89456
89457
89458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89459   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89460
89461   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89462   {
89463     try {
89464       (arg1)->Deactivate();
89465     } catch (std::out_of_range& e) {
89466       {
89467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89468       };
89469     } catch (std::exception& e) {
89470       {
89471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89472       };
89473     } catch (Dali::DaliException e) {
89474       {
89475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89476       };
89477     } catch (...) {
89478       {
89479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89480       };
89481     }
89482   }
89483
89484 }
89485
89486
89487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89488   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89489   Dali::Image arg2 ;
89490   Dali::FrameBufferImage arg3 ;
89491   Dali::Image *argp2 ;
89492   Dali::FrameBufferImage *argp3 ;
89493
89494   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89495   argp2 = (Dali::Image *)jarg2;
89496   if (!argp2) {
89497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89498     return ;
89499   }
89500   arg2 = *argp2;
89501   argp3 = (Dali::FrameBufferImage *)jarg3;
89502   if (!argp3) {
89503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89504     return ;
89505   }
89506   arg3 = *argp3;
89507   {
89508     try {
89509       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89510     } catch (std::out_of_range& e) {
89511       {
89512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89513       };
89514     } catch (std::exception& e) {
89515       {
89516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89517       };
89518     } catch (Dali::DaliException e) {
89519       {
89520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89521       };
89522     } catch (...) {
89523       {
89524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89525       };
89526     }
89527   }
89528
89529 }
89530
89531
89532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89533   int jresult ;
89534   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89535   Dali::Property::Index result;
89536
89537   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89538   {
89539     try {
89540       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89541     } catch (std::out_of_range& e) {
89542       {
89543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89544       };
89545     } catch (std::exception& e) {
89546       {
89547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89548       };
89549     } catch (Dali::DaliException e) {
89550       {
89551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89552       };
89553     } catch (...) {
89554       {
89555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89556       };
89557     }
89558   }
89559
89560   jresult = result;
89561   return jresult;
89562 }
89563
89564
89565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89566   void * jresult ;
89567   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89568   Dali::FrameBufferImage result;
89569
89570   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89571   {
89572     try {
89573       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89574     } catch (std::out_of_range& e) {
89575       {
89576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89577       };
89578     } catch (std::exception& e) {
89579       {
89580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89581       };
89582     } catch (Dali::DaliException e) {
89583       {
89584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89585       };
89586     } catch (...) {
89587       {
89588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89589       };
89590     }
89591   }
89592
89593   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89594   return jresult;
89595 }
89596
89597
89598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89599   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89600   Dali::Vector4 *arg2 = 0 ;
89601
89602   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89603   arg2 = (Dali::Vector4 *)jarg2;
89604   if (!arg2) {
89605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89606     return ;
89607   }
89608   {
89609     try {
89610       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89611     } catch (std::out_of_range& e) {
89612       {
89613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89614       };
89615     } catch (std::exception& e) {
89616       {
89617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89618       };
89619     } catch (Dali::DaliException e) {
89620       {
89621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89622       };
89623     } catch (...) {
89624       {
89625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89626       };
89627     }
89628   }
89629
89630 }
89631
89632
89633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89634   void * jresult ;
89635   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89636   Dali::Vector4 result;
89637
89638   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89639   {
89640     try {
89641       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89642     } catch (std::out_of_range& e) {
89643       {
89644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89645       };
89646     } catch (std::exception& e) {
89647       {
89648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89649       };
89650     } catch (Dali::DaliException e) {
89651       {
89652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89653       };
89654     } catch (...) {
89655       {
89656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89657       };
89658     }
89659   }
89660
89661   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89662   return jresult;
89663 }
89664
89665
89666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89667   void * jresult ;
89668   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89669   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89670
89671   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89672   {
89673     try {
89674       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89675     } catch (std::out_of_range& e) {
89676       {
89677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89678       };
89679     } catch (std::exception& e) {
89680       {
89681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89682       };
89683     } catch (Dali::DaliException e) {
89684       {
89685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89686       };
89687     } catch (...) {
89688       {
89689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89690       };
89691     }
89692   }
89693
89694   jresult = (void *)result;
89695   return jresult;
89696 }
89697
89698
89699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89700   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89701
89702   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89703   {
89704     try {
89705       delete arg1;
89706     } catch (std::out_of_range& e) {
89707       {
89708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89709       };
89710     } catch (std::exception& e) {
89711       {
89712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89713       };
89714     } catch (Dali::DaliException e) {
89715       {
89716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89717       };
89718     } catch (...) {
89719       {
89720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89721       };
89722     }
89723   }
89724
89725 }
89726
89727
89728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89729   unsigned int jresult ;
89730   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89731   unsigned int result;
89732
89733   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89734   {
89735     try {
89736       result = (unsigned int)(arg1)->GetNumberOfPages();
89737     } catch (std::out_of_range& e) {
89738       {
89739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89740       };
89741     } catch (std::exception& e) {
89742       {
89743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89744       };
89745     } catch (Dali::DaliException e) {
89746       {
89747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89748       };
89749     } catch (...) {
89750       {
89751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89752       };
89753     }
89754   }
89755
89756   jresult = result;
89757   return jresult;
89758 }
89759
89760
89761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89762   void * jresult ;
89763   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89764   unsigned int arg2 ;
89765   Dali::Texture result;
89766
89767   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89768   arg2 = (unsigned int)jarg2;
89769   {
89770     try {
89771       result = (arg1)->NewPage(arg2);
89772     } catch (std::out_of_range& e) {
89773       {
89774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89775       };
89776     } catch (std::exception& e) {
89777       {
89778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89779       };
89780     } catch (Dali::DaliException e) {
89781       {
89782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89783       };
89784     } catch (...) {
89785       {
89786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89787       };
89788     }
89789   }
89790
89791   jresult = new Dali::Texture((const Dali::Texture &)result);
89792   return jresult;
89793 }
89794
89795
89796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89797   int jresult ;
89798   int result;
89799
89800   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89801   jresult = (int)result;
89802   return jresult;
89803 }
89804
89805
89806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89807   int jresult ;
89808   int result;
89809
89810   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89811   jresult = (int)result;
89812   return jresult;
89813 }
89814
89815
89816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89817   int jresult ;
89818   int result;
89819
89820   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89821   jresult = (int)result;
89822   return jresult;
89823 }
89824
89825
89826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89827   void * jresult ;
89828   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89829
89830   {
89831     try {
89832       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89833     } catch (std::out_of_range& e) {
89834       {
89835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89836       };
89837     } catch (std::exception& e) {
89838       {
89839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89840       };
89841     } catch (Dali::DaliException e) {
89842       {
89843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89844       };
89845     } catch (...) {
89846       {
89847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89848       };
89849     }
89850   }
89851
89852   jresult = (void *)result;
89853   return jresult;
89854 }
89855
89856
89857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89858   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89859
89860   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89861   {
89862     try {
89863       delete arg1;
89864     } catch (std::out_of_range& e) {
89865       {
89866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89867       };
89868     } catch (std::exception& e) {
89869       {
89870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89871       };
89872     } catch (Dali::DaliException e) {
89873       {
89874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89875       };
89876     } catch (...) {
89877       {
89878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89879       };
89880     }
89881   }
89882
89883 }
89884
89885
89886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89887   void * jresult ;
89888   Dali::Toolkit::PageTurnView *result = 0 ;
89889
89890   {
89891     try {
89892       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89893     } catch (std::out_of_range& e) {
89894       {
89895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89896       };
89897     } catch (std::exception& e) {
89898       {
89899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89900       };
89901     } catch (Dali::DaliException e) {
89902       {
89903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89904       };
89905     } catch (...) {
89906       {
89907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89908       };
89909     }
89910   }
89911
89912   jresult = (void *)result;
89913   return jresult;
89914 }
89915
89916
89917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89918   void * jresult ;
89919   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89920   Dali::Toolkit::PageTurnView *result = 0 ;
89921
89922   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89923   if (!arg1) {
89924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89925     return 0;
89926   }
89927   {
89928     try {
89929       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89930     } catch (std::out_of_range& e) {
89931       {
89932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89933       };
89934     } catch (std::exception& e) {
89935       {
89936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89937       };
89938     } catch (Dali::DaliException e) {
89939       {
89940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89941       };
89942     } catch (...) {
89943       {
89944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89945       };
89946     }
89947   }
89948
89949   jresult = (void *)result;
89950   return jresult;
89951 }
89952
89953
89954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89955   void * jresult ;
89956   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89957   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89958   Dali::Toolkit::PageTurnView *result = 0 ;
89959
89960   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89961   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89962   if (!arg2) {
89963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89964     return 0;
89965   }
89966   {
89967     try {
89968       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89969     } catch (std::out_of_range& e) {
89970       {
89971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89972       };
89973     } catch (std::exception& e) {
89974       {
89975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89976       };
89977     } catch (Dali::DaliException e) {
89978       {
89979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89980       };
89981     } catch (...) {
89982       {
89983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89984       };
89985     }
89986   }
89987
89988   jresult = (void *)result;
89989   return jresult;
89990 }
89991
89992
89993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89994   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89995
89996   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89997   {
89998     try {
89999       delete arg1;
90000     } catch (std::out_of_range& e) {
90001       {
90002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90003       };
90004     } catch (std::exception& e) {
90005       {
90006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90007       };
90008     } catch (Dali::DaliException e) {
90009       {
90010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90011       };
90012     } catch (...) {
90013       {
90014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90015       };
90016     }
90017   }
90018
90019 }
90020
90021
90022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90023   void * jresult ;
90024   Dali::BaseHandle arg1 ;
90025   Dali::BaseHandle *argp1 ;
90026   Dali::Toolkit::PageTurnView result;
90027
90028   argp1 = (Dali::BaseHandle *)jarg1;
90029   if (!argp1) {
90030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90031     return 0;
90032   }
90033   arg1 = *argp1;
90034   {
90035     try {
90036       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90037     } catch (std::out_of_range& e) {
90038       {
90039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90040       };
90041     } catch (std::exception& e) {
90042       {
90043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90044       };
90045     } catch (Dali::DaliException e) {
90046       {
90047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90048       };
90049     } catch (...) {
90050       {
90051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90052       };
90053     }
90054   }
90055
90056   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90057   return jresult;
90058 }
90059
90060
90061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90062   void * jresult ;
90063   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90064   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90065
90066   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90067   {
90068     try {
90069       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90070     } catch (std::out_of_range& e) {
90071       {
90072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90073       };
90074     } catch (std::exception& e) {
90075       {
90076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90077       };
90078     } catch (Dali::DaliException e) {
90079       {
90080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90081       };
90082     } catch (...) {
90083       {
90084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90085       };
90086     }
90087   }
90088
90089   jresult = (void *)result;
90090   return jresult;
90091 }
90092
90093
90094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90095   void * jresult ;
90096   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90097   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90098
90099   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90100   {
90101     try {
90102       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90103     } catch (std::out_of_range& e) {
90104       {
90105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90106       };
90107     } catch (std::exception& e) {
90108       {
90109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90110       };
90111     } catch (Dali::DaliException e) {
90112       {
90113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90114       };
90115     } catch (...) {
90116       {
90117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90118       };
90119     }
90120   }
90121
90122   jresult = (void *)result;
90123   return jresult;
90124 }
90125
90126
90127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90128   void * jresult ;
90129   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90130   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90131
90132   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90133   {
90134     try {
90135       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90136     } catch (std::out_of_range& e) {
90137       {
90138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90139       };
90140     } catch (std::exception& e) {
90141       {
90142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90143       };
90144     } catch (Dali::DaliException e) {
90145       {
90146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90147       };
90148     } catch (...) {
90149       {
90150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90151       };
90152     }
90153   }
90154
90155   jresult = (void *)result;
90156   return jresult;
90157 }
90158
90159
90160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90161   void * jresult ;
90162   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90163   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90164
90165   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90166   {
90167     try {
90168       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90169     } catch (std::out_of_range& e) {
90170       {
90171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90172       };
90173     } catch (std::exception& e) {
90174       {
90175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90176       };
90177     } catch (Dali::DaliException e) {
90178       {
90179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90180       };
90181     } catch (...) {
90182       {
90183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90184       };
90185     }
90186   }
90187
90188   jresult = (void *)result;
90189   return jresult;
90190 }
90191
90192
90193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90194   void * jresult ;
90195   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90196
90197   {
90198     try {
90199       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90200     } catch (std::out_of_range& e) {
90201       {
90202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90203       };
90204     } catch (std::exception& e) {
90205       {
90206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90207       };
90208     } catch (Dali::DaliException e) {
90209       {
90210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90211       };
90212     } catch (...) {
90213       {
90214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90215       };
90216     }
90217   }
90218
90219   jresult = (void *)result;
90220   return jresult;
90221 }
90222
90223
90224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90225   void * jresult ;
90226   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90227   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90228
90229   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90230   if (!arg1) {
90231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90232     return 0;
90233   }
90234   {
90235     try {
90236       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90237     } catch (std::out_of_range& e) {
90238       {
90239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90240       };
90241     } catch (std::exception& e) {
90242       {
90243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90244       };
90245     } catch (Dali::DaliException e) {
90246       {
90247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90248       };
90249     } catch (...) {
90250       {
90251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90252       };
90253     }
90254   }
90255
90256   jresult = (void *)result;
90257   return jresult;
90258 }
90259
90260
90261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90262   void * jresult ;
90263   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90264   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90265   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90266
90267   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90268   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90269   if (!arg2) {
90270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90271     return 0;
90272   }
90273   {
90274     try {
90275       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90276     } catch (std::out_of_range& e) {
90277       {
90278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90279       };
90280     } catch (std::exception& e) {
90281       {
90282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90283       };
90284     } catch (Dali::DaliException e) {
90285       {
90286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90287       };
90288     } catch (...) {
90289       {
90290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90291       };
90292     }
90293   }
90294
90295   jresult = (void *)result;
90296   return jresult;
90297 }
90298
90299
90300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90301   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90302
90303   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90304   {
90305     try {
90306       delete arg1;
90307     } catch (std::out_of_range& e) {
90308       {
90309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90310       };
90311     } catch (std::exception& e) {
90312       {
90313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90314       };
90315     } catch (Dali::DaliException e) {
90316       {
90317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90318       };
90319     } catch (...) {
90320       {
90321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90322       };
90323     }
90324   }
90325
90326 }
90327
90328
90329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90330   void * jresult ;
90331   Dali::Toolkit::PageFactory *arg1 = 0 ;
90332   Dali::Vector2 *arg2 = 0 ;
90333   Dali::Toolkit::PageTurnLandscapeView result;
90334
90335   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90336   if (!arg1) {
90337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90338     return 0;
90339   }
90340   arg2 = (Dali::Vector2 *)jarg2;
90341   if (!arg2) {
90342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90343     return 0;
90344   }
90345   {
90346     try {
90347       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90348     } catch (std::out_of_range& e) {
90349       {
90350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90351       };
90352     } catch (std::exception& e) {
90353       {
90354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90355       };
90356     } catch (Dali::DaliException e) {
90357       {
90358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90359       };
90360     } catch (...) {
90361       {
90362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90363       };
90364     }
90365   }
90366
90367   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90368   return jresult;
90369 }
90370
90371
90372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90373   void * jresult ;
90374   Dali::BaseHandle arg1 ;
90375   Dali::BaseHandle *argp1 ;
90376   Dali::Toolkit::PageTurnLandscapeView result;
90377
90378   argp1 = (Dali::BaseHandle *)jarg1;
90379   if (!argp1) {
90380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90381     return 0;
90382   }
90383   arg1 = *argp1;
90384   {
90385     try {
90386       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90387     } catch (std::out_of_range& e) {
90388       {
90389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90390       };
90391     } catch (std::exception& e) {
90392       {
90393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90394       };
90395     } catch (Dali::DaliException e) {
90396       {
90397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90398       };
90399     } catch (...) {
90400       {
90401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90402       };
90403     }
90404   }
90405
90406   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90407   return jresult;
90408 }
90409
90410
90411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90412   void * jresult ;
90413   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90414
90415   {
90416     try {
90417       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90418     } catch (std::out_of_range& e) {
90419       {
90420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90421       };
90422     } catch (std::exception& e) {
90423       {
90424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90425       };
90426     } catch (Dali::DaliException e) {
90427       {
90428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90429       };
90430     } catch (...) {
90431       {
90432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90433       };
90434     }
90435   }
90436
90437   jresult = (void *)result;
90438   return jresult;
90439 }
90440
90441
90442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90443   void * jresult ;
90444   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90445   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90446
90447   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90448   if (!arg1) {
90449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90450     return 0;
90451   }
90452   {
90453     try {
90454       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90455     } catch (std::out_of_range& e) {
90456       {
90457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90458       };
90459     } catch (std::exception& e) {
90460       {
90461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90462       };
90463     } catch (Dali::DaliException e) {
90464       {
90465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90466       };
90467     } catch (...) {
90468       {
90469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90470       };
90471     }
90472   }
90473
90474   jresult = (void *)result;
90475   return jresult;
90476 }
90477
90478
90479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90480   void * jresult ;
90481   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90482   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90483   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90484
90485   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90486   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90487   if (!arg2) {
90488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90489     return 0;
90490   }
90491   {
90492     try {
90493       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90494     } catch (std::out_of_range& e) {
90495       {
90496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90497       };
90498     } catch (std::exception& e) {
90499       {
90500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90501       };
90502     } catch (Dali::DaliException e) {
90503       {
90504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90505       };
90506     } catch (...) {
90507       {
90508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90509       };
90510     }
90511   }
90512
90513   jresult = (void *)result;
90514   return jresult;
90515 }
90516
90517
90518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90519   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90520
90521   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90522   {
90523     try {
90524       delete arg1;
90525     } catch (std::out_of_range& e) {
90526       {
90527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90528       };
90529     } catch (std::exception& e) {
90530       {
90531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90532       };
90533     } catch (Dali::DaliException e) {
90534       {
90535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90536       };
90537     } catch (...) {
90538       {
90539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90540       };
90541     }
90542   }
90543
90544 }
90545
90546
90547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90548   void * jresult ;
90549   Dali::Toolkit::PageFactory *arg1 = 0 ;
90550   Dali::Vector2 *arg2 = 0 ;
90551   Dali::Toolkit::PageTurnPortraitView result;
90552
90553   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90554   if (!arg1) {
90555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90556     return 0;
90557   }
90558   arg2 = (Dali::Vector2 *)jarg2;
90559   if (!arg2) {
90560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90561     return 0;
90562   }
90563   {
90564     try {
90565       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90566     } catch (std::out_of_range& e) {
90567       {
90568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90569       };
90570     } catch (std::exception& e) {
90571       {
90572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90573       };
90574     } catch (Dali::DaliException e) {
90575       {
90576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90577       };
90578     } catch (...) {
90579       {
90580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90581       };
90582     }
90583   }
90584
90585   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90586   return jresult;
90587 }
90588
90589
90590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90591   void * jresult ;
90592   Dali::BaseHandle arg1 ;
90593   Dali::BaseHandle *argp1 ;
90594   Dali::Toolkit::PageTurnPortraitView result;
90595
90596   argp1 = (Dali::BaseHandle *)jarg1;
90597   if (!argp1) {
90598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90599     return 0;
90600   }
90601   arg1 = *argp1;
90602   {
90603     try {
90604       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90605     } catch (std::out_of_range& e) {
90606       {
90607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90608       };
90609     } catch (std::exception& e) {
90610       {
90611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90612       };
90613     } catch (Dali::DaliException e) {
90614       {
90615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90616       };
90617     } catch (...) {
90618       {
90619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90620       };
90621     }
90622   }
90623
90624   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90625   return jresult;
90626 }
90627
90628
90629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90630   int jresult ;
90631   int result;
90632
90633   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90634   jresult = (int)result;
90635   return jresult;
90636 }
90637
90638
90639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90640   int jresult ;
90641   int result;
90642
90643   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90644   jresult = (int)result;
90645   return jresult;
90646 }
90647
90648
90649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90650   int jresult ;
90651   int result;
90652
90653   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90654   jresult = (int)result;
90655   return jresult;
90656 }
90657
90658
90659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90660   void * jresult ;
90661   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90662
90663   {
90664     try {
90665       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90666     } catch (std::out_of_range& e) {
90667       {
90668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90669       };
90670     } catch (std::exception& e) {
90671       {
90672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90673       };
90674     } catch (Dali::DaliException e) {
90675       {
90676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90677       };
90678     } catch (...) {
90679       {
90680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90681       };
90682     }
90683   }
90684
90685   jresult = (void *)result;
90686   return jresult;
90687 }
90688
90689
90690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90691   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90692
90693   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90694   {
90695     try {
90696       delete arg1;
90697     } catch (std::out_of_range& e) {
90698       {
90699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90700       };
90701     } catch (std::exception& e) {
90702       {
90703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90704       };
90705     } catch (Dali::DaliException e) {
90706       {
90707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90708       };
90709     } catch (...) {
90710       {
90711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90712       };
90713     }
90714   }
90715
90716 }
90717
90718
90719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90720   void * jresult ;
90721   Dali::Toolkit::ToggleButton *result = 0 ;
90722
90723   {
90724     try {
90725       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90726     } catch (std::out_of_range& e) {
90727       {
90728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90729       };
90730     } catch (std::exception& e) {
90731       {
90732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90733       };
90734     } catch (Dali::DaliException e) {
90735       {
90736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90737       };
90738     } catch (...) {
90739       {
90740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90741       };
90742     }
90743   }
90744
90745   jresult = (void *)result;
90746   return jresult;
90747 }
90748
90749
90750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90751   void * jresult ;
90752   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90753   Dali::Toolkit::ToggleButton *result = 0 ;
90754
90755   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90756   if (!arg1) {
90757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90758     return 0;
90759   }
90760   {
90761     try {
90762       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90763     } catch (std::out_of_range& e) {
90764       {
90765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90766       };
90767     } catch (std::exception& e) {
90768       {
90769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90770       };
90771     } catch (Dali::DaliException e) {
90772       {
90773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90774       };
90775     } catch (...) {
90776       {
90777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90778       };
90779     }
90780   }
90781
90782   jresult = (void *)result;
90783   return jresult;
90784 }
90785
90786
90787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90788   void * jresult ;
90789   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90790   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90791   Dali::Toolkit::ToggleButton *result = 0 ;
90792
90793   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90794   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90795   if (!arg2) {
90796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90797     return 0;
90798   }
90799   {
90800     try {
90801       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90802     } catch (std::out_of_range& e) {
90803       {
90804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90805       };
90806     } catch (std::exception& e) {
90807       {
90808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90809       };
90810     } catch (Dali::DaliException e) {
90811       {
90812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90813       };
90814     } catch (...) {
90815       {
90816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90817       };
90818     }
90819   }
90820
90821   jresult = (void *)result;
90822   return jresult;
90823 }
90824
90825
90826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90827   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90828
90829   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90830   {
90831     try {
90832       delete arg1;
90833     } catch (std::out_of_range& e) {
90834       {
90835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90836       };
90837     } catch (std::exception& e) {
90838       {
90839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90840       };
90841     } catch (Dali::DaliException e) {
90842       {
90843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90844       };
90845     } catch (...) {
90846       {
90847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90848       };
90849     }
90850   }
90851
90852 }
90853
90854
90855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90856   void * jresult ;
90857   Dali::Toolkit::ToggleButton result;
90858
90859   {
90860     try {
90861       result = Dali::Toolkit::ToggleButton::New();
90862     } catch (std::out_of_range& e) {
90863       {
90864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90865       };
90866     } catch (std::exception& e) {
90867       {
90868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90869       };
90870     } catch (Dali::DaliException e) {
90871       {
90872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90873       };
90874     } catch (...) {
90875       {
90876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90877       };
90878     }
90879   }
90880
90881   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90882   return jresult;
90883 }
90884
90885
90886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90887   void * jresult ;
90888   Dali::BaseHandle arg1 ;
90889   Dali::BaseHandle *argp1 ;
90890   Dali::Toolkit::ToggleButton result;
90891
90892   argp1 = (Dali::BaseHandle *)jarg1;
90893   if (!argp1) {
90894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90895     return 0;
90896   }
90897   arg1 = *argp1;
90898   {
90899     try {
90900       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90901     } catch (std::out_of_range& e) {
90902       {
90903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90904       };
90905     } catch (std::exception& e) {
90906       {
90907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90908       };
90909     } catch (Dali::DaliException e) {
90910       {
90911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90912       };
90913     } catch (...) {
90914       {
90915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90916       };
90917     }
90918   }
90919
90920   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90921   return jresult;
90922 }
90923
90924
90925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90926   void * jresult ;
90927   Dali::Toolkit::Visual::Base *result = 0 ;
90928
90929   {
90930     try {
90931       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90932     } catch (std::out_of_range& e) {
90933       {
90934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90935       };
90936     } catch (std::exception& e) {
90937       {
90938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90939       };
90940     } catch (Dali::DaliException e) {
90941       {
90942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90943       };
90944     } catch (...) {
90945       {
90946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90947       };
90948     }
90949   }
90950
90951   jresult = (void *)result;
90952   return jresult;
90953 }
90954
90955
90956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90957   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90958
90959   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90960   {
90961     try {
90962       delete arg1;
90963     } catch (std::out_of_range& e) {
90964       {
90965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90966       };
90967     } catch (std::exception& e) {
90968       {
90969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90970       };
90971     } catch (Dali::DaliException e) {
90972       {
90973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90974       };
90975     } catch (...) {
90976       {
90977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90978       };
90979     }
90980   }
90981
90982 }
90983
90984
90985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90986   void * jresult ;
90987   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90988   Dali::Toolkit::Visual::Base *result = 0 ;
90989
90990   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90991   if (!arg1) {
90992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90993     return 0;
90994   }
90995   {
90996     try {
90997       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
90998     } catch (std::out_of_range& e) {
90999       {
91000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91001       };
91002     } catch (std::exception& e) {
91003       {
91004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91005       };
91006     } catch (Dali::DaliException e) {
91007       {
91008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91009       };
91010     } catch (...) {
91011       {
91012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91013       };
91014     }
91015   }
91016
91017   jresult = (void *)result;
91018   return jresult;
91019 }
91020
91021
91022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91023   void * jresult ;
91024   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91025   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91026   Dali::Toolkit::Visual::Base *result = 0 ;
91027
91028   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91029   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91030   if (!arg2) {
91031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91032     return 0;
91033   }
91034   {
91035     try {
91036       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91037     } catch (std::out_of_range& e) {
91038       {
91039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91040       };
91041     } catch (std::exception& e) {
91042       {
91043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91044       };
91045     } catch (Dali::DaliException e) {
91046       {
91047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91048       };
91049     } catch (...) {
91050       {
91051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91052       };
91053     }
91054   }
91055
91056   jresult = (void *)result;
91057   return jresult;
91058 }
91059
91060
91061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91062   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91063   std::string *arg2 = 0 ;
91064
91065   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91066   if (!jarg2) {
91067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91068     return ;
91069   }
91070   std::string arg2_str(jarg2);
91071   arg2 = &arg2_str;
91072   {
91073     try {
91074       (arg1)->SetName((std::string const &)*arg2);
91075     } catch (std::out_of_range& e) {
91076       {
91077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91078       };
91079     } catch (std::exception& e) {
91080       {
91081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91082       };
91083     } catch (Dali::DaliException e) {
91084       {
91085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91086       };
91087     } catch (...) {
91088       {
91089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91090       };
91091     }
91092   }
91093
91094
91095   //argout typemap for const std::string&
91096
91097 }
91098
91099
91100 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91101   char * jresult ;
91102   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91103   std::string *result = 0 ;
91104
91105   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91106   {
91107     try {
91108       result = (std::string *) &(arg1)->GetName();
91109     } catch (std::out_of_range& e) {
91110       {
91111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91112       };
91113     } catch (std::exception& e) {
91114       {
91115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91116       };
91117     } catch (Dali::DaliException e) {
91118       {
91119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91120       };
91121     } catch (...) {
91122       {
91123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91124       };
91125     }
91126   }
91127
91128   jresult = SWIG_csharp_string_callback(result->c_str());
91129   return jresult;
91130 }
91131
91132
91133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91134   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91135   Dali::Property::Map *arg2 = 0 ;
91136   Dali::Size arg3 ;
91137   Dali::Size *argp3 ;
91138
91139   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91140   arg2 = (Dali::Property::Map *)jarg2;
91141   if (!arg2) {
91142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91143     return ;
91144   }
91145   argp3 = (Dali::Size *)jarg3;
91146   if (!argp3) {
91147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91148     return ;
91149   }
91150   arg3 = *argp3;
91151   {
91152     try {
91153       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91154     } catch (std::out_of_range& e) {
91155       {
91156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91157       };
91158     } catch (std::exception& e) {
91159       {
91160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91161       };
91162     } catch (Dali::DaliException e) {
91163       {
91164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91165       };
91166     } catch (...) {
91167       {
91168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91169       };
91170     }
91171   }
91172
91173 }
91174
91175
91176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91177   float jresult ;
91178   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91179   float arg2 ;
91180   float result;
91181
91182   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91183   arg2 = (float)jarg2;
91184   {
91185     try {
91186       result = (float)(arg1)->GetHeightForWidth(arg2);
91187     } catch (std::out_of_range& e) {
91188       {
91189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91190       };
91191     } catch (std::exception& e) {
91192       {
91193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91194       };
91195     } catch (Dali::DaliException e) {
91196       {
91197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91198       };
91199     } catch (...) {
91200       {
91201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91202       };
91203     }
91204   }
91205
91206   jresult = result;
91207   return jresult;
91208 }
91209
91210
91211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91212   float jresult ;
91213   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91214   float arg2 ;
91215   float result;
91216
91217   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91218   arg2 = (float)jarg2;
91219   {
91220     try {
91221       result = (float)(arg1)->GetWidthForHeight(arg2);
91222     } catch (std::out_of_range& e) {
91223       {
91224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91225       };
91226     } catch (std::exception& e) {
91227       {
91228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91229       };
91230     } catch (Dali::DaliException e) {
91231       {
91232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91233       };
91234     } catch (...) {
91235       {
91236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91237       };
91238     }
91239   }
91240
91241   jresult = result;
91242   return jresult;
91243 }
91244
91245
91246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91247   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91248   Dali::Vector2 *arg2 = 0 ;
91249
91250   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91251   arg2 = (Dali::Vector2 *)jarg2;
91252   if (!arg2) {
91253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91254     return ;
91255   }
91256   {
91257     try {
91258       (arg1)->GetNaturalSize(*arg2);
91259     } catch (std::out_of_range& e) {
91260       {
91261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91262       };
91263     } catch (std::exception& e) {
91264       {
91265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91266       };
91267     } catch (Dali::DaliException e) {
91268       {
91269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91270       };
91271     } catch (...) {
91272       {
91273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91274       };
91275     }
91276   }
91277
91278 }
91279
91280
91281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91282   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91283   float arg2 ;
91284
91285   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91286   arg2 = (int)jarg2;
91287   {
91288     try {
91289       (arg1)->SetDepthIndex(arg2);
91290     } catch (std::out_of_range& e) {
91291       {
91292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91293       };
91294     } catch (std::exception& e) {
91295       {
91296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91297       };
91298     } catch (Dali::DaliException e) {
91299       {
91300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91301       };
91302     } catch (...) {
91303       {
91304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91305       };
91306     }
91307   }
91308
91309 }
91310
91311
91312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91313   int jresult ;
91314   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91315   int result;
91316
91317   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91318   {
91319     try {
91320       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91321     } catch (std::out_of_range& e) {
91322       {
91323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91324       };
91325     } catch (std::exception& e) {
91326       {
91327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91328       };
91329     } catch (Dali::DaliException e) {
91330       {
91331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91332       };
91333     } catch (...) {
91334       {
91335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91336       };
91337     }
91338   }
91339
91340   jresult = result;
91341   return jresult;
91342 }
91343
91344
91345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91346   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91347   Dali::Property::Map *arg2 = 0 ;
91348
91349   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91350   arg2 = (Dali::Property::Map *)jarg2;
91351   if (!arg2) {
91352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91353     return ;
91354   }
91355   {
91356     try {
91357       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91358     } catch (std::out_of_range& e) {
91359       {
91360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91361       };
91362     } catch (std::exception& e) {
91363       {
91364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91365       };
91366     } catch (Dali::DaliException e) {
91367       {
91368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91369       };
91370     } catch (...) {
91371       {
91372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91373       };
91374     }
91375   }
91376
91377 }
91378
91379
91380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
91381   void * jresult ;
91382   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
91383   Dali::Toolkit::Visual::Base *result = 0 ;
91384
91385   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
91386   {
91387     try {
91388       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
91389     } catch (std::out_of_range& e) {
91390       {
91391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91392       };
91393     } catch (std::exception& e) {
91394       {
91395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91396       };
91397     } catch (Dali::DaliException e) {
91398       {
91399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91400       };
91401     } catch (...) {
91402       {
91403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91404       };
91405     }
91406   }
91407
91408   jresult = (void *)result;
91409   return jresult;
91410 }
91411
91412
91413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91414   void * jresult ;
91415   Dali::Toolkit::VisualFactory result;
91416
91417   {
91418     try {
91419       result = Dali::Toolkit::VisualFactory::Get();
91420     } catch (std::out_of_range& e) {
91421       {
91422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91423       };
91424     } catch (std::exception& e) {
91425       {
91426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91427       };
91428     } catch (Dali::DaliException e) {
91429       {
91430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91431       };
91432     } catch (...) {
91433       {
91434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91435       };
91436     }
91437   }
91438
91439   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91440   return jresult;
91441 }
91442
91443
91444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91445   void * jresult ;
91446   Dali::Toolkit::VisualFactory *result = 0 ;
91447
91448   {
91449     try {
91450       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91451     } catch (std::out_of_range& e) {
91452       {
91453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91454       };
91455     } catch (std::exception& e) {
91456       {
91457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91458       };
91459     } catch (Dali::DaliException e) {
91460       {
91461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91462       };
91463     } catch (...) {
91464       {
91465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91466       };
91467     }
91468   }
91469
91470   jresult = (void *)result;
91471   return jresult;
91472 }
91473
91474
91475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91476   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91477
91478   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91479   {
91480     try {
91481       delete arg1;
91482     } catch (std::out_of_range& e) {
91483       {
91484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91485       };
91486     } catch (std::exception& e) {
91487       {
91488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91489       };
91490     } catch (Dali::DaliException e) {
91491       {
91492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91493       };
91494     } catch (...) {
91495       {
91496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91497       };
91498     }
91499   }
91500
91501 }
91502
91503
91504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91505   void * jresult ;
91506   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91507   Dali::Toolkit::VisualFactory *result = 0 ;
91508
91509   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91510   if (!arg1) {
91511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91512     return 0;
91513   }
91514   {
91515     try {
91516       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91517     } catch (std::out_of_range& e) {
91518       {
91519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91520       };
91521     } catch (std::exception& e) {
91522       {
91523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91524       };
91525     } catch (Dali::DaliException e) {
91526       {
91527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91528       };
91529     } catch (...) {
91530       {
91531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91532       };
91533     }
91534   }
91535
91536   jresult = (void *)result;
91537   return jresult;
91538 }
91539
91540
91541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91542   void * jresult ;
91543   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91544   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91545   Dali::Toolkit::VisualFactory *result = 0 ;
91546
91547   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91548   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91549   if (!arg2) {
91550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91551     return 0;
91552   }
91553   {
91554     try {
91555       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91556     } catch (std::out_of_range& e) {
91557       {
91558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91559       };
91560     } catch (std::exception& e) {
91561       {
91562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91563       };
91564     } catch (Dali::DaliException e) {
91565       {
91566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91567       };
91568     } catch (...) {
91569       {
91570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91571       };
91572     }
91573   }
91574
91575   jresult = (void *)result;
91576   return jresult;
91577 }
91578
91579
91580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91581   void * jresult ;
91582   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91583   Dali::Property::Map *arg2 = 0 ;
91584   Dali::Toolkit::Visual::Base result;
91585
91586   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91587   arg2 = (Dali::Property::Map *)jarg2;
91588   if (!arg2) {
91589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91590     return 0;
91591   }
91592   {
91593     try {
91594       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91595     } catch (std::out_of_range& e) {
91596       {
91597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91598       };
91599     } catch (std::exception& e) {
91600       {
91601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91602       };
91603     } catch (Dali::DaliException e) {
91604       {
91605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91606       };
91607     } catch (...) {
91608       {
91609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91610       };
91611     }
91612   }
91613
91614   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91615   return jresult;
91616 }
91617
91618
91619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91620   void * jresult ;
91621   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91622   Dali::Image *arg2 = 0 ;
91623   Dali::Toolkit::Visual::Base result;
91624
91625   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91626   arg2 = (Dali::Image *)jarg2;
91627   if (!arg2) {
91628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91629     return 0;
91630   }
91631   {
91632     try {
91633       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91634     } catch (std::out_of_range& e) {
91635       {
91636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91637       };
91638     } catch (std::exception& e) {
91639       {
91640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91641       };
91642     } catch (Dali::DaliException e) {
91643       {
91644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91645       };
91646     } catch (...) {
91647       {
91648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91649       };
91650     }
91651   }
91652
91653   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91654   return jresult;
91655 }
91656
91657
91658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91659   void * jresult ;
91660   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91661   std::string *arg2 = 0 ;
91662   Dali::ImageDimensions arg3 ;
91663   Dali::ImageDimensions *argp3 ;
91664   Dali::Toolkit::Visual::Base result;
91665
91666   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91667   if (!jarg2) {
91668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91669     return 0;
91670   }
91671   std::string arg2_str(jarg2);
91672   arg2 = &arg2_str;
91673   argp3 = (Dali::ImageDimensions *)jarg3;
91674   if (!argp3) {
91675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91676     return 0;
91677   }
91678   arg3 = *argp3;
91679   {
91680     try {
91681       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91682     } catch (std::out_of_range& e) {
91683       {
91684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91685       };
91686     } catch (std::exception& e) {
91687       {
91688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91689       };
91690     } catch (Dali::DaliException e) {
91691       {
91692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91693       };
91694     } catch (...) {
91695       {
91696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91697       };
91698     }
91699   }
91700
91701   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91702
91703   //argout typemap for const std::string&
91704
91705   return jresult;
91706 }
91707
91708
91709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91710   void * jresult ;
91711   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91712
91713   {
91714     try {
91715       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91716     } catch (std::out_of_range& e) {
91717       {
91718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91719       };
91720     } catch (std::exception& e) {
91721       {
91722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91723       };
91724     } catch (Dali::DaliException e) {
91725       {
91726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91727       };
91728     } catch (...) {
91729       {
91730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91731       };
91732     }
91733   }
91734
91735   jresult = (void *)result;
91736   return jresult;
91737 }
91738
91739
91740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91741   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91742
91743   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91744   {
91745     try {
91746       delete arg1;
91747     } catch (std::out_of_range& e) {
91748       {
91749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91750       };
91751     } catch (std::exception& e) {
91752       {
91753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91754       };
91755     } catch (Dali::DaliException e) {
91756       {
91757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91758       };
91759     } catch (...) {
91760       {
91761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91762       };
91763     }
91764   }
91765
91766 }
91767
91768
91769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91770   void * jresult ;
91771   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91772   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91773
91774   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91775   if (!arg1) {
91776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91777     return 0;
91778   }
91779   {
91780     try {
91781       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91782     } catch (std::out_of_range& e) {
91783       {
91784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91785       };
91786     } catch (std::exception& e) {
91787       {
91788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91789       };
91790     } catch (Dali::DaliException e) {
91791       {
91792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91793       };
91794     } catch (...) {
91795       {
91796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91797       };
91798     }
91799   }
91800
91801   jresult = (void *)result;
91802   return jresult;
91803 }
91804
91805
91806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91807   void * jresult ;
91808   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91809   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91810   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91811
91812   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91813   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91814   if (!arg2) {
91815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91816     return 0;
91817   }
91818   {
91819     try {
91820       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91821     } catch (std::out_of_range& e) {
91822       {
91823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91824       };
91825     } catch (std::exception& e) {
91826       {
91827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91828       };
91829     } catch (Dali::DaliException e) {
91830       {
91831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91832       };
91833     } catch (...) {
91834       {
91835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91836       };
91837     }
91838   }
91839
91840   jresult = (void *)result;
91841   return jresult;
91842 }
91843
91844
91845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91846   void * jresult ;
91847   Dali::Toolkit::AsyncImageLoader result;
91848
91849   {
91850     try {
91851       result = Dali::Toolkit::AsyncImageLoader::New();
91852     } catch (std::out_of_range& e) {
91853       {
91854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91855       };
91856     } catch (std::exception& e) {
91857       {
91858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91859       };
91860     } catch (Dali::DaliException e) {
91861       {
91862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91863       };
91864     } catch (...) {
91865       {
91866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91867       };
91868     }
91869   }
91870
91871   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91872   return jresult;
91873 }
91874
91875
91876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91877   void * jresult ;
91878   Dali::BaseHandle arg1 ;
91879   Dali::BaseHandle *argp1 ;
91880   Dali::Toolkit::AsyncImageLoader result;
91881
91882   argp1 = (Dali::BaseHandle *)jarg1;
91883   if (!argp1) {
91884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91885     return 0;
91886   }
91887   arg1 = *argp1;
91888   {
91889     try {
91890       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91891     } catch (std::out_of_range& e) {
91892       {
91893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91894       };
91895     } catch (std::exception& e) {
91896       {
91897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91898       };
91899     } catch (Dali::DaliException e) {
91900       {
91901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91902       };
91903     } catch (...) {
91904       {
91905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91906       };
91907     }
91908   }
91909
91910   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91911   return jresult;
91912 }
91913
91914
91915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91916   unsigned int jresult ;
91917   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91918   std::string *arg2 = 0 ;
91919   uint32_t result;
91920
91921   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91922   if (!jarg2) {
91923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91924     return 0;
91925   }
91926   std::string arg2_str(jarg2);
91927   arg2 = &arg2_str;
91928   {
91929     try {
91930       result = (arg1)->Load((std::string const &)*arg2);
91931     } catch (std::out_of_range& e) {
91932       {
91933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91934       };
91935     } catch (std::exception& e) {
91936       {
91937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91938       };
91939     } catch (Dali::DaliException e) {
91940       {
91941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91942       };
91943     } catch (...) {
91944       {
91945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91946       };
91947     }
91948   }
91949
91950   jresult = result;
91951
91952   //argout typemap for const std::string&
91953
91954   return jresult;
91955 }
91956
91957
91958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91959   unsigned int jresult ;
91960   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91961   std::string *arg2 = 0 ;
91962   Dali::ImageDimensions arg3 ;
91963   Dali::ImageDimensions *argp3 ;
91964   uint32_t result;
91965
91966   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91967   if (!jarg2) {
91968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91969     return 0;
91970   }
91971   std::string arg2_str(jarg2);
91972   arg2 = &arg2_str;
91973   argp3 = (Dali::ImageDimensions *)jarg3;
91974   if (!argp3) {
91975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91976     return 0;
91977   }
91978   arg3 = *argp3;
91979   {
91980     try {
91981       result = (arg1)->Load((std::string const &)*arg2,arg3);
91982     } catch (std::out_of_range& e) {
91983       {
91984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91985       };
91986     } catch (std::exception& e) {
91987       {
91988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91989       };
91990     } catch (Dali::DaliException e) {
91991       {
91992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91993       };
91994     } catch (...) {
91995       {
91996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91997       };
91998     }
91999   }
92000
92001   jresult = result;
92002
92003   //argout typemap for const std::string&
92004
92005   return jresult;
92006 }
92007
92008
92009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92010   unsigned int jresult ;
92011   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92012   std::string *arg2 = 0 ;
92013   Dali::ImageDimensions arg3 ;
92014   Dali::FittingMode::Type arg4 ;
92015   Dali::SamplingMode::Type arg5 ;
92016   bool arg6 ;
92017   Dali::ImageDimensions *argp3 ;
92018   uint32_t result;
92019
92020   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92021   if (!jarg2) {
92022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92023     return 0;
92024   }
92025   std::string arg2_str(jarg2);
92026   arg2 = &arg2_str;
92027   argp3 = (Dali::ImageDimensions *)jarg3;
92028   if (!argp3) {
92029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92030     return 0;
92031   }
92032   arg3 = *argp3;
92033   arg4 = (Dali::FittingMode::Type)jarg4;
92034   arg5 = (Dali::SamplingMode::Type)jarg5;
92035   arg6 = jarg6 ? true : false;
92036   {
92037     try {
92038       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92039     } catch (std::out_of_range& e) {
92040       {
92041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92042       };
92043     } catch (std::exception& e) {
92044       {
92045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92046       };
92047     } catch (Dali::DaliException e) {
92048       {
92049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92050       };
92051     } catch (...) {
92052       {
92053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92054       };
92055     }
92056   }
92057
92058   jresult = result;
92059
92060   //argout typemap for const std::string&
92061
92062   return jresult;
92063 }
92064
92065
92066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92067   unsigned int jresult ;
92068   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92069   uint32_t arg2 ;
92070   bool result;
92071
92072   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92073   arg2 = (uint32_t)jarg2;
92074   {
92075     try {
92076       result = (bool)(arg1)->Cancel(arg2);
92077     } catch (std::out_of_range& e) {
92078       {
92079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92080       };
92081     } catch (std::exception& e) {
92082       {
92083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92084       };
92085     } catch (Dali::DaliException e) {
92086       {
92087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92088       };
92089     } catch (...) {
92090       {
92091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92092       };
92093     }
92094   }
92095
92096   jresult = result;
92097   return jresult;
92098 }
92099
92100
92101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92102   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92103
92104   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92105   {
92106     try {
92107       (arg1)->CancelAll();
92108     } catch (std::out_of_range& e) {
92109       {
92110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92111       };
92112     } catch (std::exception& e) {
92113       {
92114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92115       };
92116     } catch (Dali::DaliException e) {
92117       {
92118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92119       };
92120     } catch (...) {
92121       {
92122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92123       };
92124     }
92125   }
92126
92127 }
92128
92129
92130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92131   void * jresult ;
92132   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92133   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92134
92135   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92136   {
92137     try {
92138       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92139     } catch (std::out_of_range& e) {
92140       {
92141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92142       };
92143     } catch (std::exception& e) {
92144       {
92145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92146       };
92147     } catch (Dali::DaliException e) {
92148       {
92149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92150       };
92151     } catch (...) {
92152       {
92153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92154       };
92155     }
92156   }
92157
92158   jresult = (void *)result;
92159   return jresult;
92160 }
92161
92162
92163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
92164   void * jresult ;
92165   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
92166   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92167
92168   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
92169   {
92170     try {
92171       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
92172     } catch (std::out_of_range& e) {
92173       {
92174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92175       };
92176     } catch (std::exception& e) {
92177       {
92178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92179       };
92180     } catch (Dali::DaliException e) {
92181       {
92182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92183       };
92184     } catch (...) {
92185       {
92186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92187       };
92188     }
92189   }
92190
92191   jresult = (void *)result;
92192   return jresult;
92193 }
92194
92195
92196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92197   void * jresult ;
92198   std::string *arg1 = 0 ;
92199   Dali::PixelData result;
92200
92201   if (!jarg1) {
92202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92203     return 0;
92204   }
92205   std::string arg1_str(jarg1);
92206   arg1 = &arg1_str;
92207   {
92208     try {
92209       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92210     } catch (std::out_of_range& e) {
92211       {
92212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92213       };
92214     } catch (std::exception& e) {
92215       {
92216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92217       };
92218     } catch (Dali::DaliException e) {
92219       {
92220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92221       };
92222     } catch (...) {
92223       {
92224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92225       };
92226     }
92227   }
92228
92229   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92230
92231   //argout typemap for const std::string&
92232
92233   return jresult;
92234 }
92235
92236
92237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92238   void * jresult ;
92239   std::string *arg1 = 0 ;
92240   Dali::ImageDimensions arg2 ;
92241   Dali::ImageDimensions *argp2 ;
92242   Dali::PixelData result;
92243
92244   if (!jarg1) {
92245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92246     return 0;
92247   }
92248   std::string arg1_str(jarg1);
92249   arg1 = &arg1_str;
92250   argp2 = (Dali::ImageDimensions *)jarg2;
92251   if (!argp2) {
92252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92253     return 0;
92254   }
92255   arg2 = *argp2;
92256   {
92257     try {
92258       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92259     } catch (std::out_of_range& e) {
92260       {
92261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92262       };
92263     } catch (std::exception& e) {
92264       {
92265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92266       };
92267     } catch (Dali::DaliException e) {
92268       {
92269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92270       };
92271     } catch (...) {
92272       {
92273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92274       };
92275     }
92276   }
92277
92278   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92279
92280   //argout typemap for const std::string&
92281
92282   return jresult;
92283 }
92284
92285
92286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92287   void * jresult ;
92288   std::string *arg1 = 0 ;
92289   Dali::ImageDimensions arg2 ;
92290   Dali::FittingMode::Type arg3 ;
92291   Dali::SamplingMode::Type arg4 ;
92292   bool arg5 ;
92293   Dali::ImageDimensions *argp2 ;
92294   Dali::PixelData result;
92295
92296   if (!jarg1) {
92297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92298     return 0;
92299   }
92300   std::string arg1_str(jarg1);
92301   arg1 = &arg1_str;
92302   argp2 = (Dali::ImageDimensions *)jarg2;
92303   if (!argp2) {
92304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92305     return 0;
92306   }
92307   arg2 = *argp2;
92308   arg3 = (Dali::FittingMode::Type)jarg3;
92309   arg4 = (Dali::SamplingMode::Type)jarg4;
92310   arg5 = jarg5 ? true : false;
92311   {
92312     try {
92313       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92314     } catch (std::out_of_range& e) {
92315       {
92316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92317       };
92318     } catch (std::exception& e) {
92319       {
92320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92321       };
92322     } catch (Dali::DaliException e) {
92323       {
92324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92325       };
92326     } catch (...) {
92327       {
92328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92329       };
92330     }
92331   }
92332
92333   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92334
92335   //argout typemap for const std::string&
92336
92337   return jresult;
92338 }
92339
92340
92341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92342   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92343
92344   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92345   {
92346     try {
92347       delete arg1;
92348     } catch (std::out_of_range& e) {
92349       {
92350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92351       };
92352     } catch (std::exception& e) {
92353       {
92354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92355       };
92356     } catch (Dali::DaliException e) {
92357       {
92358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92359       };
92360     } catch (...) {
92361       {
92362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92363       };
92364     }
92365   }
92366
92367 }
92368
92369
92370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92371   void * jresult ;
92372   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92373   Dali::Actor arg2 ;
92374   Dali::Actor arg3 ;
92375   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92376   Dali::Actor *argp2 ;
92377   Dali::Actor *argp3 ;
92378   Dali::Actor result;
92379
92380   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92381   argp2 = (Dali::Actor *)jarg2;
92382   if (!argp2) {
92383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92384     return 0;
92385   }
92386   arg2 = *argp2;
92387   argp3 = (Dali::Actor *)jarg3;
92388   if (!argp3) {
92389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92390     return 0;
92391   }
92392   arg3 = *argp3;
92393   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92394   {
92395     try {
92396       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92397     } catch (std::out_of_range& e) {
92398       {
92399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92400       };
92401     } catch (std::exception& e) {
92402       {
92403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92404       };
92405     } catch (Dali::DaliException e) {
92406       {
92407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92408       };
92409     } catch (...) {
92410       {
92411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92412       };
92413     }
92414   }
92415
92416   jresult = new Dali::Actor((const Dali::Actor &)result);
92417   return jresult;
92418 }
92419
92420
92421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92422   void * jresult ;
92423   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92424
92425   {
92426     try {
92427       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92428     } catch (std::out_of_range& e) {
92429       {
92430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92431       };
92432     } catch (std::exception& e) {
92433       {
92434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92435       };
92436     } catch (Dali::DaliException e) {
92437       {
92438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92439       };
92440     } catch (...) {
92441       {
92442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92443       };
92444     }
92445   }
92446
92447   jresult = (void *)result;
92448   return jresult;
92449 }
92450
92451
92452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92453   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92454   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92455   if (director) {
92456     director->swig_connect_director(callback0);
92457   }
92458 }
92459
92460
92461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92462   KeyboardFocusManager arg1 ;
92463   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92464   KeyboardFocusManager *argp1 ;
92465
92466   argp1 = (KeyboardFocusManager *)jarg1;
92467   if (!argp1) {
92468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92469     return ;
92470   }
92471   arg1 = *argp1;
92472   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92473   if (!arg2) {
92474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92475     return ;
92476   }
92477   {
92478     try {
92479       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92480     } catch (std::out_of_range& e) {
92481       {
92482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92483       };
92484     } catch (std::exception& e) {
92485       {
92486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92487       };
92488     } catch (Dali::DaliException e) {
92489       {
92490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92491       };
92492     } catch (...) {
92493       {
92494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92495       };
92496     }
92497   }
92498
92499 }
92500
92501
92502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92503   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92504
92505   arg1 = (std::vector< unsigned int > *)jarg1;
92506   {
92507     try {
92508       (arg1)->clear();
92509     } catch (std::out_of_range& e) {
92510       {
92511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92512       };
92513     } catch (std::exception& e) {
92514       {
92515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92516       };
92517     } catch (Dali::DaliException e) {
92518       {
92519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92520       };
92521     } catch (...) {
92522       {
92523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92524       };
92525     }
92526   }
92527
92528 }
92529
92530
92531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92532   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92533   unsigned int *arg2 = 0 ;
92534   unsigned int temp2 ;
92535
92536   arg1 = (std::vector< unsigned int > *)jarg1;
92537   temp2 = (unsigned int)jarg2;
92538   arg2 = &temp2;
92539   {
92540     try {
92541       (arg1)->push_back((unsigned int const &)*arg2);
92542     } catch (std::out_of_range& e) {
92543       {
92544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92545       };
92546     } catch (std::exception& e) {
92547       {
92548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92549       };
92550     } catch (Dali::DaliException e) {
92551       {
92552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92553       };
92554     } catch (...) {
92555       {
92556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92557       };
92558     }
92559   }
92560
92561 }
92562
92563
92564 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92565   unsigned long jresult ;
92566   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92567   std::vector< unsigned int >::size_type result;
92568
92569   arg1 = (std::vector< unsigned int > *)jarg1;
92570   {
92571     try {
92572       result = ((std::vector< unsigned int > const *)arg1)->size();
92573     } catch (std::out_of_range& e) {
92574       {
92575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92576       };
92577     } catch (std::exception& e) {
92578       {
92579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92580       };
92581     } catch (Dali::DaliException e) {
92582       {
92583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92584       };
92585     } catch (...) {
92586       {
92587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92588       };
92589     }
92590   }
92591
92592   jresult = (unsigned long)result;
92593   return jresult;
92594 }
92595
92596
92597 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92598   unsigned long jresult ;
92599   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92600   std::vector< unsigned int >::size_type result;
92601
92602   arg1 = (std::vector< unsigned int > *)jarg1;
92603   {
92604     try {
92605       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92606     } catch (std::out_of_range& e) {
92607       {
92608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92609       };
92610     } catch (std::exception& e) {
92611       {
92612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92613       };
92614     } catch (Dali::DaliException e) {
92615       {
92616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92617       };
92618     } catch (...) {
92619       {
92620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92621       };
92622     }
92623   }
92624
92625   jresult = (unsigned long)result;
92626   return jresult;
92627 }
92628
92629
92630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92631   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92632   std::vector< unsigned int >::size_type arg2 ;
92633
92634   arg1 = (std::vector< unsigned int > *)jarg1;
92635   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92636   {
92637     try {
92638       (arg1)->reserve(arg2);
92639     } catch (std::out_of_range& e) {
92640       {
92641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92642       };
92643     } catch (std::exception& e) {
92644       {
92645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92646       };
92647     } catch (Dali::DaliException e) {
92648       {
92649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92650       };
92651     } catch (...) {
92652       {
92653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92654       };
92655     }
92656   }
92657
92658 }
92659
92660
92661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92662   void * jresult ;
92663   std::vector< unsigned int > *result = 0 ;
92664
92665   {
92666     try {
92667       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92668     } catch (std::out_of_range& e) {
92669       {
92670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92671       };
92672     } catch (std::exception& e) {
92673       {
92674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92675       };
92676     } catch (Dali::DaliException e) {
92677       {
92678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92679       };
92680     } catch (...) {
92681       {
92682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92683       };
92684     }
92685   }
92686
92687   jresult = (void *)result;
92688   return jresult;
92689 }
92690
92691
92692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92693   void * jresult ;
92694   std::vector< unsigned int > *arg1 = 0 ;
92695   std::vector< unsigned int > *result = 0 ;
92696
92697   arg1 = (std::vector< unsigned int > *)jarg1;
92698   if (!arg1) {
92699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92700     return 0;
92701   }
92702   {
92703     try {
92704       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92705     } catch (std::out_of_range& e) {
92706       {
92707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92708       };
92709     } catch (std::exception& e) {
92710       {
92711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92712       };
92713     } catch (Dali::DaliException e) {
92714       {
92715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92716       };
92717     } catch (...) {
92718       {
92719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92720       };
92721     }
92722   }
92723
92724   jresult = (void *)result;
92725   return jresult;
92726 }
92727
92728
92729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92730   void * jresult ;
92731   int arg1 ;
92732   std::vector< unsigned int > *result = 0 ;
92733
92734   arg1 = (int)jarg1;
92735   {
92736     try {
92737       try {
92738         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92739       }
92740       catch(std::out_of_range &_e) {
92741         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92742         return 0;
92743       }
92744
92745     } catch (std::out_of_range& e) {
92746       {
92747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92748       };
92749     } catch (std::exception& e) {
92750       {
92751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92752       };
92753     } catch (Dali::DaliException e) {
92754       {
92755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92756       };
92757     } catch (...) {
92758       {
92759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92760       };
92761     }
92762   }
92763
92764   jresult = (void *)result;
92765   return jresult;
92766 }
92767
92768
92769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92770   unsigned int jresult ;
92771   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92772   int arg2 ;
92773   unsigned int result;
92774
92775   arg1 = (std::vector< unsigned int > *)jarg1;
92776   arg2 = (int)jarg2;
92777   {
92778     try {
92779       try {
92780         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92781       }
92782       catch(std::out_of_range &_e) {
92783         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92784         return 0;
92785       }
92786
92787     } catch (std::out_of_range& e) {
92788       {
92789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92790       };
92791     } catch (std::exception& e) {
92792       {
92793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92794       };
92795     } catch (Dali::DaliException e) {
92796       {
92797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92798       };
92799     } catch (...) {
92800       {
92801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92802       };
92803     }
92804   }
92805
92806   jresult = result;
92807   return jresult;
92808 }
92809
92810
92811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92812   unsigned int jresult ;
92813   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92814   int arg2 ;
92815   unsigned int *result = 0 ;
92816
92817   arg1 = (std::vector< unsigned int > *)jarg1;
92818   arg2 = (int)jarg2;
92819   {
92820     try {
92821       try {
92822         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92823       }
92824       catch(std::out_of_range &_e) {
92825         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92826         return 0;
92827       }
92828
92829     } catch (std::out_of_range& e) {
92830       {
92831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92832       };
92833     } catch (std::exception& e) {
92834       {
92835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92836       };
92837     } catch (Dali::DaliException e) {
92838       {
92839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92840       };
92841     } catch (...) {
92842       {
92843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92844       };
92845     }
92846   }
92847
92848   jresult = *result;
92849   return jresult;
92850 }
92851
92852
92853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92854   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92855   int arg2 ;
92856   unsigned int *arg3 = 0 ;
92857   unsigned int temp3 ;
92858
92859   arg1 = (std::vector< unsigned int > *)jarg1;
92860   arg2 = (int)jarg2;
92861   temp3 = (unsigned int)jarg3;
92862   arg3 = &temp3;
92863   {
92864     try {
92865       try {
92866         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92867       }
92868       catch(std::out_of_range &_e) {
92869         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92870         return ;
92871       }
92872
92873     } catch (std::out_of_range& e) {
92874       {
92875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92876       };
92877     } catch (std::exception& e) {
92878       {
92879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92880       };
92881     } catch (Dali::DaliException e) {
92882       {
92883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92884       };
92885     } catch (...) {
92886       {
92887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92888       };
92889     }
92890   }
92891
92892 }
92893
92894
92895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92896   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92897   std::vector< unsigned int > *arg2 = 0 ;
92898
92899   arg1 = (std::vector< unsigned int > *)jarg1;
92900   arg2 = (std::vector< unsigned int > *)jarg2;
92901   if (!arg2) {
92902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92903     return ;
92904   }
92905   {
92906     try {
92907       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92908     } catch (std::out_of_range& e) {
92909       {
92910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92911       };
92912     } catch (std::exception& e) {
92913       {
92914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92915       };
92916     } catch (Dali::DaliException e) {
92917       {
92918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92919       };
92920     } catch (...) {
92921       {
92922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92923       };
92924     }
92925   }
92926
92927 }
92928
92929
92930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92931   void * jresult ;
92932   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92933   int arg2 ;
92934   int arg3 ;
92935   std::vector< unsigned int > *result = 0 ;
92936
92937   arg1 = (std::vector< unsigned int > *)jarg1;
92938   arg2 = (int)jarg2;
92939   arg3 = (int)jarg3;
92940   {
92941     try {
92942       try {
92943         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92944       }
92945       catch(std::out_of_range &_e) {
92946         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92947         return 0;
92948       }
92949       catch(std::invalid_argument &_e) {
92950         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92951         return 0;
92952       }
92953
92954     } catch (std::out_of_range& e) {
92955       {
92956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92957       };
92958     } catch (std::exception& e) {
92959       {
92960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92961       };
92962     } catch (Dali::DaliException e) {
92963       {
92964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92965       };
92966     } catch (...) {
92967       {
92968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92969       };
92970     }
92971   }
92972
92973   jresult = (void *)result;
92974   return jresult;
92975 }
92976
92977
92978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92979   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92980   int arg2 ;
92981   unsigned int *arg3 = 0 ;
92982   unsigned int temp3 ;
92983
92984   arg1 = (std::vector< unsigned int > *)jarg1;
92985   arg2 = (int)jarg2;
92986   temp3 = (unsigned int)jarg3;
92987   arg3 = &temp3;
92988   {
92989     try {
92990       try {
92991         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92992       }
92993       catch(std::out_of_range &_e) {
92994         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92995         return ;
92996       }
92997
92998     } catch (std::out_of_range& e) {
92999       {
93000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93001       };
93002     } catch (std::exception& e) {
93003       {
93004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93005       };
93006     } catch (Dali::DaliException e) {
93007       {
93008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93009       };
93010     } catch (...) {
93011       {
93012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93013       };
93014     }
93015   }
93016
93017 }
93018
93019
93020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93021   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93022   int arg2 ;
93023   std::vector< unsigned int > *arg3 = 0 ;
93024
93025   arg1 = (std::vector< unsigned int > *)jarg1;
93026   arg2 = (int)jarg2;
93027   arg3 = (std::vector< unsigned int > *)jarg3;
93028   if (!arg3) {
93029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93030     return ;
93031   }
93032   {
93033     try {
93034       try {
93035         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93036       }
93037       catch(std::out_of_range &_e) {
93038         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93039         return ;
93040       }
93041
93042     } catch (std::out_of_range& e) {
93043       {
93044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93045       };
93046     } catch (std::exception& e) {
93047       {
93048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93049       };
93050     } catch (Dali::DaliException e) {
93051       {
93052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93053       };
93054     } catch (...) {
93055       {
93056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93057       };
93058     }
93059   }
93060
93061 }
93062
93063
93064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93065   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93066   int arg2 ;
93067
93068   arg1 = (std::vector< unsigned int > *)jarg1;
93069   arg2 = (int)jarg2;
93070   {
93071     try {
93072       try {
93073         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93074       }
93075       catch(std::out_of_range &_e) {
93076         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93077         return ;
93078       }
93079
93080     } catch (std::out_of_range& e) {
93081       {
93082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93083       };
93084     } catch (std::exception& e) {
93085       {
93086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93087       };
93088     } catch (Dali::DaliException e) {
93089       {
93090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93091       };
93092     } catch (...) {
93093       {
93094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93095       };
93096     }
93097   }
93098
93099 }
93100
93101
93102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93103   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93104   int arg2 ;
93105   int arg3 ;
93106
93107   arg1 = (std::vector< unsigned int > *)jarg1;
93108   arg2 = (int)jarg2;
93109   arg3 = (int)jarg3;
93110   {
93111     try {
93112       try {
93113         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93114       }
93115       catch(std::out_of_range &_e) {
93116         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93117         return ;
93118       }
93119       catch(std::invalid_argument &_e) {
93120         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93121         return ;
93122       }
93123
93124     } catch (std::out_of_range& e) {
93125       {
93126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93127       };
93128     } catch (std::exception& e) {
93129       {
93130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93131       };
93132     } catch (Dali::DaliException e) {
93133       {
93134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93135       };
93136     } catch (...) {
93137       {
93138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93139       };
93140     }
93141   }
93142
93143 }
93144
93145
93146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93147   void * jresult ;
93148   unsigned int *arg1 = 0 ;
93149   int arg2 ;
93150   unsigned int temp1 ;
93151   std::vector< unsigned int > *result = 0 ;
93152
93153   temp1 = (unsigned int)jarg1;
93154   arg1 = &temp1;
93155   arg2 = (int)jarg2;
93156   {
93157     try {
93158       try {
93159         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93160       }
93161       catch(std::out_of_range &_e) {
93162         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93163         return 0;
93164       }
93165
93166     } catch (std::out_of_range& e) {
93167       {
93168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93169       };
93170     } catch (std::exception& e) {
93171       {
93172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93173       };
93174     } catch (Dali::DaliException e) {
93175       {
93176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93177       };
93178     } catch (...) {
93179       {
93180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93181       };
93182     }
93183   }
93184
93185   jresult = (void *)result;
93186   return jresult;
93187 }
93188
93189
93190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93191   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93192
93193   arg1 = (std::vector< unsigned int > *)jarg1;
93194   {
93195     try {
93196       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93197     } catch (std::out_of_range& e) {
93198       {
93199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93200       };
93201     } catch (std::exception& e) {
93202       {
93203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93204       };
93205     } catch (Dali::DaliException e) {
93206       {
93207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93208       };
93209     } catch (...) {
93210       {
93211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93212       };
93213     }
93214   }
93215
93216 }
93217
93218
93219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93220   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93221   int arg2 ;
93222   int arg3 ;
93223
93224   arg1 = (std::vector< unsigned int > *)jarg1;
93225   arg2 = (int)jarg2;
93226   arg3 = (int)jarg3;
93227   {
93228     try {
93229       try {
93230         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93231       }
93232       catch(std::out_of_range &_e) {
93233         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93234         return ;
93235       }
93236       catch(std::invalid_argument &_e) {
93237         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93238         return ;
93239       }
93240
93241     } catch (std::out_of_range& e) {
93242       {
93243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93244       };
93245     } catch (std::exception& e) {
93246       {
93247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93248       };
93249     } catch (Dali::DaliException e) {
93250       {
93251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93252       };
93253     } catch (...) {
93254       {
93255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93256       };
93257     }
93258   }
93259
93260 }
93261
93262
93263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93264   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93265   int arg2 ;
93266   std::vector< unsigned int > *arg3 = 0 ;
93267
93268   arg1 = (std::vector< unsigned int > *)jarg1;
93269   arg2 = (int)jarg2;
93270   arg3 = (std::vector< unsigned int > *)jarg3;
93271   if (!arg3) {
93272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93273     return ;
93274   }
93275   {
93276     try {
93277       try {
93278         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93279       }
93280       catch(std::out_of_range &_e) {
93281         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93282         return ;
93283       }
93284
93285     } catch (std::out_of_range& e) {
93286       {
93287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93288       };
93289     } catch (std::exception& e) {
93290       {
93291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93292       };
93293     } catch (Dali::DaliException e) {
93294       {
93295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93296       };
93297     } catch (...) {
93298       {
93299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93300       };
93301     }
93302   }
93303
93304 }
93305
93306
93307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93308   unsigned int jresult ;
93309   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93310   unsigned int *arg2 = 0 ;
93311   unsigned int temp2 ;
93312   bool result;
93313
93314   arg1 = (std::vector< unsigned int > *)jarg1;
93315   temp2 = (unsigned int)jarg2;
93316   arg2 = &temp2;
93317   {
93318     try {
93319       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93320     } catch (std::out_of_range& e) {
93321       {
93322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93323       };
93324     } catch (std::exception& e) {
93325       {
93326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93327       };
93328     } catch (Dali::DaliException e) {
93329       {
93330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93331       };
93332     } catch (...) {
93333       {
93334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93335       };
93336     }
93337   }
93338
93339   jresult = result;
93340   return jresult;
93341 }
93342
93343
93344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93345   int jresult ;
93346   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93347   unsigned int *arg2 = 0 ;
93348   unsigned int temp2 ;
93349   int result;
93350
93351   arg1 = (std::vector< unsigned int > *)jarg1;
93352   temp2 = (unsigned int)jarg2;
93353   arg2 = &temp2;
93354   {
93355     try {
93356       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93357     } catch (std::out_of_range& e) {
93358       {
93359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93360       };
93361     } catch (std::exception& e) {
93362       {
93363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93364       };
93365     } catch (Dali::DaliException e) {
93366       {
93367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93368       };
93369     } catch (...) {
93370       {
93371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93372       };
93373     }
93374   }
93375
93376   jresult = result;
93377   return jresult;
93378 }
93379
93380
93381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93382   int jresult ;
93383   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93384   unsigned int *arg2 = 0 ;
93385   unsigned int temp2 ;
93386   int result;
93387
93388   arg1 = (std::vector< unsigned int > *)jarg1;
93389   temp2 = (unsigned int)jarg2;
93390   arg2 = &temp2;
93391   {
93392     try {
93393       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93394     } catch (std::out_of_range& e) {
93395       {
93396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93397       };
93398     } catch (std::exception& e) {
93399       {
93400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93401       };
93402     } catch (Dali::DaliException e) {
93403       {
93404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93405       };
93406     } catch (...) {
93407       {
93408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93409       };
93410     }
93411   }
93412
93413   jresult = result;
93414   return jresult;
93415 }
93416
93417
93418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93419   unsigned int jresult ;
93420   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93421   unsigned int *arg2 = 0 ;
93422   unsigned int temp2 ;
93423   bool result;
93424
93425   arg1 = (std::vector< unsigned int > *)jarg1;
93426   temp2 = (unsigned int)jarg2;
93427   arg2 = &temp2;
93428   {
93429     try {
93430       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93431     } catch (std::out_of_range& e) {
93432       {
93433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93434       };
93435     } catch (std::exception& e) {
93436       {
93437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93438       };
93439     } catch (Dali::DaliException e) {
93440       {
93441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93442       };
93443     } catch (...) {
93444       {
93445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93446       };
93447     }
93448   }
93449
93450   jresult = result;
93451   return jresult;
93452 }
93453
93454
93455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93456   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93457
93458   arg1 = (std::vector< unsigned int > *)jarg1;
93459   {
93460     try {
93461       delete arg1;
93462     } catch (std::out_of_range& e) {
93463       {
93464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93465       };
93466     } catch (std::exception& e) {
93467       {
93468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93469       };
93470     } catch (Dali::DaliException e) {
93471       {
93472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93473       };
93474     } catch (...) {
93475       {
93476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93477       };
93478     }
93479   }
93480
93481 }
93482
93483
93484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93485   void * jresult ;
93486   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93487
93488   {
93489     try {
93490       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93491     } catch (std::out_of_range& e) {
93492       {
93493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93494       };
93495     } catch (std::exception& e) {
93496       {
93497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93498       };
93499     } catch (Dali::DaliException e) {
93500       {
93501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93502       };
93503     } catch (...) {
93504       {
93505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93506       };
93507     }
93508   }
93509
93510   jresult = (void *)result;
93511   return jresult;
93512 }
93513
93514
93515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93516   void * jresult ;
93517   unsigned int arg1 ;
93518   Dali::Actor arg2 ;
93519   Dali::Actor *argp2 ;
93520   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93521
93522   arg1 = (unsigned int)jarg1;
93523   argp2 = (Dali::Actor *)jarg2;
93524   if (!argp2) {
93525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93526     return 0;
93527   }
93528   arg2 = *argp2;
93529   {
93530     try {
93531       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93532     } catch (std::out_of_range& e) {
93533       {
93534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93535       };
93536     } catch (std::exception& e) {
93537       {
93538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93539       };
93540     } catch (Dali::DaliException e) {
93541       {
93542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93543       };
93544     } catch (...) {
93545       {
93546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93547       };
93548     }
93549   }
93550
93551   jresult = (void *)result;
93552   return jresult;
93553 }
93554
93555
93556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93557   void * jresult ;
93558   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93559   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93560
93561   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93562   if (!arg1) {
93563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93564     return 0;
93565   }
93566   {
93567     try {
93568       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93569     } catch (std::out_of_range& e) {
93570       {
93571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93572       };
93573     } catch (std::exception& e) {
93574       {
93575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93576       };
93577     } catch (Dali::DaliException e) {
93578       {
93579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93580       };
93581     } catch (...) {
93582       {
93583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93584       };
93585     }
93586   }
93587
93588   jresult = (void *)result;
93589   return jresult;
93590 }
93591
93592
93593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93594   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93595   unsigned int arg2 ;
93596
93597   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93598   arg2 = (unsigned int)jarg2;
93599   if (arg1) (arg1)->first = arg2;
93600 }
93601
93602
93603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93604   unsigned int jresult ;
93605   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93606   unsigned int result;
93607
93608   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93609   result = (unsigned int) ((arg1)->first);
93610   jresult = result;
93611   return jresult;
93612 }
93613
93614
93615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93616   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93617   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93618
93619   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93620   arg2 = (Dali::Actor *)jarg2;
93621   if (arg1) (arg1)->second = *arg2;
93622 }
93623
93624
93625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93626   void * jresult ;
93627   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93628   Dali::Actor *result = 0 ;
93629
93630   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93631   result = (Dali::Actor *)& ((arg1)->second);
93632   jresult = (void *)result;
93633   return jresult;
93634 }
93635
93636
93637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93638   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93639
93640   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93641   {
93642     try {
93643       delete arg1;
93644     } catch (std::out_of_range& e) {
93645       {
93646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93647       };
93648     } catch (std::exception& e) {
93649       {
93650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93651       };
93652     } catch (Dali::DaliException e) {
93653       {
93654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93655       };
93656     } catch (...) {
93657       {
93658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93659       };
93660     }
93661   }
93662
93663 }
93664
93665
93666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93667   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93668
93669   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93670   {
93671     try {
93672       (arg1)->clear();
93673     } catch (std::out_of_range& e) {
93674       {
93675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93676       };
93677     } catch (std::exception& e) {
93678       {
93679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93680       };
93681     } catch (Dali::DaliException e) {
93682       {
93683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93684       };
93685     } catch (...) {
93686       {
93687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93688       };
93689     }
93690   }
93691
93692 }
93693
93694
93695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93696   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93697   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93698
93699   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93700   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93701   if (!arg2) {
93702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93703     return ;
93704   }
93705   {
93706     try {
93707       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93708     } catch (std::out_of_range& e) {
93709       {
93710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93711       };
93712     } catch (std::exception& e) {
93713       {
93714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93715       };
93716     } catch (Dali::DaliException e) {
93717       {
93718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93719       };
93720     } catch (...) {
93721       {
93722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93723       };
93724     }
93725   }
93726
93727 }
93728
93729
93730 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93731   unsigned long jresult ;
93732   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93733   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93734
93735   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93736   {
93737     try {
93738       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93739     } catch (std::out_of_range& e) {
93740       {
93741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93742       };
93743     } catch (std::exception& e) {
93744       {
93745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93746       };
93747     } catch (Dali::DaliException e) {
93748       {
93749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93750       };
93751     } catch (...) {
93752       {
93753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93754       };
93755     }
93756   }
93757
93758   jresult = (unsigned long)result;
93759   return jresult;
93760 }
93761
93762
93763 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93764   unsigned long jresult ;
93765   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93766   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93767
93768   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93769   {
93770     try {
93771       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93772     } catch (std::out_of_range& e) {
93773       {
93774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93775       };
93776     } catch (std::exception& e) {
93777       {
93778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93779       };
93780     } catch (Dali::DaliException e) {
93781       {
93782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93783       };
93784     } catch (...) {
93785       {
93786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93787       };
93788     }
93789   }
93790
93791   jresult = (unsigned long)result;
93792   return jresult;
93793 }
93794
93795
93796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93797   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93798   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93799
93800   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93801   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93802   {
93803     try {
93804       (arg1)->reserve(arg2);
93805     } catch (std::out_of_range& e) {
93806       {
93807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93808       };
93809     } catch (std::exception& e) {
93810       {
93811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93812       };
93813     } catch (Dali::DaliException e) {
93814       {
93815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93816       };
93817     } catch (...) {
93818       {
93819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93820       };
93821     }
93822   }
93823
93824 }
93825
93826
93827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93828   void * jresult ;
93829   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93830
93831   {
93832     try {
93833       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93834     } catch (std::out_of_range& e) {
93835       {
93836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93837       };
93838     } catch (std::exception& e) {
93839       {
93840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93841       };
93842     } catch (Dali::DaliException e) {
93843       {
93844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93845       };
93846     } catch (...) {
93847       {
93848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93849       };
93850     }
93851   }
93852
93853   jresult = (void *)result;
93854   return jresult;
93855 }
93856
93857
93858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93859   void * jresult ;
93860   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93861   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93862
93863   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93864   if (!arg1) {
93865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93866     return 0;
93867   }
93868   {
93869     try {
93870       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);
93871     } catch (std::out_of_range& e) {
93872       {
93873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93874       };
93875     } catch (std::exception& e) {
93876       {
93877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93878       };
93879     } catch (Dali::DaliException e) {
93880       {
93881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93882       };
93883     } catch (...) {
93884       {
93885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93886       };
93887     }
93888   }
93889
93890   jresult = (void *)result;
93891   return jresult;
93892 }
93893
93894
93895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93896   void * jresult ;
93897   int arg1 ;
93898   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93899
93900   arg1 = (int)jarg1;
93901   {
93902     try {
93903       try {
93904         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);
93905       }
93906       catch(std::out_of_range &_e) {
93907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93908         return 0;
93909       }
93910
93911     } catch (std::out_of_range& e) {
93912       {
93913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93914       };
93915     } catch (std::exception& e) {
93916       {
93917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93918       };
93919     } catch (Dali::DaliException e) {
93920       {
93921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93922       };
93923     } catch (...) {
93924       {
93925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93926       };
93927     }
93928   }
93929
93930   jresult = (void *)result;
93931   return jresult;
93932 }
93933
93934
93935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93936   void * jresult ;
93937   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93938   int arg2 ;
93939   std::pair< unsigned int,Dali::Actor > result;
93940
93941   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93942   arg2 = (int)jarg2;
93943   {
93944     try {
93945       try {
93946         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93947       }
93948       catch(std::out_of_range &_e) {
93949         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93950         return 0;
93951       }
93952
93953     } catch (std::out_of_range& e) {
93954       {
93955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93956       };
93957     } catch (std::exception& e) {
93958       {
93959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93960       };
93961     } catch (Dali::DaliException e) {
93962       {
93963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93964       };
93965     } catch (...) {
93966       {
93967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93968       };
93969     }
93970   }
93971
93972   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93973   return jresult;
93974 }
93975
93976
93977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93978   void * jresult ;
93979   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93980   int arg2 ;
93981   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93982
93983   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93984   arg2 = (int)jarg2;
93985   {
93986     try {
93987       try {
93988         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93989       }
93990       catch(std::out_of_range &_e) {
93991         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93992         return 0;
93993       }
93994
93995     } catch (std::out_of_range& e) {
93996       {
93997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93998       };
93999     } catch (std::exception& e) {
94000       {
94001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94002       };
94003     } catch (Dali::DaliException e) {
94004       {
94005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94006       };
94007     } catch (...) {
94008       {
94009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94010       };
94011     }
94012   }
94013
94014   jresult = (void *)result;
94015   return jresult;
94016 }
94017
94018
94019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94020   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94021   int arg2 ;
94022   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94023
94024   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94025   arg2 = (int)jarg2;
94026   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94027   if (!arg3) {
94028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94029     return ;
94030   }
94031   {
94032     try {
94033       try {
94034         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);
94035       }
94036       catch(std::out_of_range &_e) {
94037         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94038         return ;
94039       }
94040
94041     } catch (std::out_of_range& e) {
94042       {
94043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94044       };
94045     } catch (std::exception& e) {
94046       {
94047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94048       };
94049     } catch (Dali::DaliException e) {
94050       {
94051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94052       };
94053     } catch (...) {
94054       {
94055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94056       };
94057     }
94058   }
94059
94060 }
94061
94062
94063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94064   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94065   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94066
94067   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94068   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94069   if (!arg2) {
94070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94071     return ;
94072   }
94073   {
94074     try {
94075       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);
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_GetRange(void * jarg1, int jarg2, int jarg3) {
94099   void * jresult ;
94100   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94101   int arg2 ;
94102   int arg3 ;
94103   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94104
94105   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94106   arg2 = (int)jarg2;
94107   arg3 = (int)jarg3;
94108   {
94109     try {
94110       try {
94111         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);
94112       }
94113       catch(std::out_of_range &_e) {
94114         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94115         return 0;
94116       }
94117       catch(std::invalid_argument &_e) {
94118         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94119         return 0;
94120       }
94121
94122     } catch (std::out_of_range& e) {
94123       {
94124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94125       };
94126     } catch (std::exception& e) {
94127       {
94128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94129       };
94130     } catch (Dali::DaliException e) {
94131       {
94132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94133       };
94134     } catch (...) {
94135       {
94136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94137       };
94138     }
94139   }
94140
94141   jresult = (void *)result;
94142   return jresult;
94143 }
94144
94145
94146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94147   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94148   int arg2 ;
94149   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94150
94151   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94152   arg2 = (int)jarg2;
94153   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94154   if (!arg3) {
94155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94156     return ;
94157   }
94158   {
94159     try {
94160       try {
94161         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);
94162       }
94163       catch(std::out_of_range &_e) {
94164         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94165         return ;
94166       }
94167
94168     } catch (std::out_of_range& e) {
94169       {
94170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94171       };
94172     } catch (std::exception& e) {
94173       {
94174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94175       };
94176     } catch (Dali::DaliException e) {
94177       {
94178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94179       };
94180     } catch (...) {
94181       {
94182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94183       };
94184     }
94185   }
94186
94187 }
94188
94189
94190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94191   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94192   int arg2 ;
94193   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94194
94195   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94196   arg2 = (int)jarg2;
94197   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94198   if (!arg3) {
94199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94200     return ;
94201   }
94202   {
94203     try {
94204       try {
94205         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);
94206       }
94207       catch(std::out_of_range &_e) {
94208         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94209         return ;
94210       }
94211
94212     } catch (std::out_of_range& e) {
94213       {
94214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94215       };
94216     } catch (std::exception& e) {
94217       {
94218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94219       };
94220     } catch (Dali::DaliException e) {
94221       {
94222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94223       };
94224     } catch (...) {
94225       {
94226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94227       };
94228     }
94229   }
94230
94231 }
94232
94233
94234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94235   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94236   int arg2 ;
94237
94238   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94239   arg2 = (int)jarg2;
94240   {
94241     try {
94242       try {
94243         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94244       }
94245       catch(std::out_of_range &_e) {
94246         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94247         return ;
94248       }
94249
94250     } catch (std::out_of_range& e) {
94251       {
94252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94253       };
94254     } catch (std::exception& e) {
94255       {
94256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94257       };
94258     } catch (Dali::DaliException e) {
94259       {
94260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94261       };
94262     } catch (...) {
94263       {
94264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94265       };
94266     }
94267   }
94268
94269 }
94270
94271
94272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94273   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94274   int arg2 ;
94275   int arg3 ;
94276
94277   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94278   arg2 = (int)jarg2;
94279   arg3 = (int)jarg3;
94280   {
94281     try {
94282       try {
94283         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94284       }
94285       catch(std::out_of_range &_e) {
94286         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94287         return ;
94288       }
94289       catch(std::invalid_argument &_e) {
94290         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94291         return ;
94292       }
94293
94294     } catch (std::out_of_range& e) {
94295       {
94296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94297       };
94298     } catch (std::exception& e) {
94299       {
94300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94301       };
94302     } catch (Dali::DaliException e) {
94303       {
94304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94305       };
94306     } catch (...) {
94307       {
94308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94309       };
94310     }
94311   }
94312
94313 }
94314
94315
94316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94317   void * jresult ;
94318   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94319   int arg2 ;
94320   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94321
94322   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94323   if (!arg1) {
94324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94325     return 0;
94326   }
94327   arg2 = (int)jarg2;
94328   {
94329     try {
94330       try {
94331         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);
94332       }
94333       catch(std::out_of_range &_e) {
94334         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94335         return 0;
94336       }
94337
94338     } catch (std::out_of_range& e) {
94339       {
94340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94341       };
94342     } catch (std::exception& e) {
94343       {
94344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94345       };
94346     } catch (Dali::DaliException e) {
94347       {
94348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94349       };
94350     } catch (...) {
94351       {
94352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94353       };
94354     }
94355   }
94356
94357   jresult = (void *)result;
94358   return jresult;
94359 }
94360
94361
94362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94363   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94364
94365   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94366   {
94367     try {
94368       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94369     } catch (std::out_of_range& e) {
94370       {
94371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94372       };
94373     } catch (std::exception& e) {
94374       {
94375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94376       };
94377     } catch (Dali::DaliException e) {
94378       {
94379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94380       };
94381     } catch (...) {
94382       {
94383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94384       };
94385     }
94386   }
94387
94388 }
94389
94390
94391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94392   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94393   int arg2 ;
94394   int arg3 ;
94395
94396   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94397   arg2 = (int)jarg2;
94398   arg3 = (int)jarg3;
94399   {
94400     try {
94401       try {
94402         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94403       }
94404       catch(std::out_of_range &_e) {
94405         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94406         return ;
94407       }
94408       catch(std::invalid_argument &_e) {
94409         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94410         return ;
94411       }
94412
94413     } catch (std::out_of_range& e) {
94414       {
94415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94416       };
94417     } catch (std::exception& e) {
94418       {
94419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94420       };
94421     } catch (Dali::DaliException e) {
94422       {
94423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94424       };
94425     } catch (...) {
94426       {
94427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94428       };
94429     }
94430   }
94431
94432 }
94433
94434
94435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94436   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94437   int arg2 ;
94438   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94439
94440   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94441   arg2 = (int)jarg2;
94442   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94443   if (!arg3) {
94444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94445     return ;
94446   }
94447   {
94448     try {
94449       try {
94450         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);
94451       }
94452       catch(std::out_of_range &_e) {
94453         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94454         return ;
94455       }
94456
94457     } catch (std::out_of_range& e) {
94458       {
94459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94460       };
94461     } catch (std::exception& e) {
94462       {
94463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94464       };
94465     } catch (Dali::DaliException e) {
94466       {
94467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94468       };
94469     } catch (...) {
94470       {
94471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94472       };
94473     }
94474   }
94475
94476 }
94477
94478
94479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94480   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94481
94482   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94483   {
94484     try {
94485       delete arg1;
94486     } catch (std::out_of_range& e) {
94487       {
94488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94489       };
94490     } catch (std::exception& e) {
94491       {
94492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94493       };
94494     } catch (Dali::DaliException e) {
94495       {
94496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94497       };
94498     } catch (...) {
94499       {
94500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94501       };
94502     }
94503   }
94504
94505 }
94506
94507
94508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94509   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94510
94511   arg1 = (std::vector< Dali::Actor > *)jarg1;
94512   {
94513     try {
94514       (arg1)->clear();
94515     } catch (std::out_of_range& e) {
94516       {
94517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94518       };
94519     } catch (std::exception& e) {
94520       {
94521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94522       };
94523     } catch (Dali::DaliException e) {
94524       {
94525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94526       };
94527     } catch (...) {
94528       {
94529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94530       };
94531     }
94532   }
94533
94534 }
94535
94536
94537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94538   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94539   Dali::Actor *arg2 = 0 ;
94540
94541   arg1 = (std::vector< Dali::Actor > *)jarg1;
94542   arg2 = (Dali::Actor *)jarg2;
94543   if (!arg2) {
94544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94545     return ;
94546   }
94547   {
94548     try {
94549       (arg1)->push_back((Dali::Actor const &)*arg2);
94550     } catch (std::out_of_range& e) {
94551       {
94552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94553       };
94554     } catch (std::exception& e) {
94555       {
94556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94557       };
94558     } catch (Dali::DaliException e) {
94559       {
94560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94561       };
94562     } catch (...) {
94563       {
94564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94565       };
94566     }
94567   }
94568
94569 }
94570
94571
94572 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94573   unsigned long jresult ;
94574   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94575   std::vector< Dali::Actor >::size_type result;
94576
94577   arg1 = (std::vector< Dali::Actor > *)jarg1;
94578   {
94579     try {
94580       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94581     } catch (std::out_of_range& e) {
94582       {
94583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94584       };
94585     } catch (std::exception& e) {
94586       {
94587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94588       };
94589     } catch (Dali::DaliException e) {
94590       {
94591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94592       };
94593     } catch (...) {
94594       {
94595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94596       };
94597     }
94598   }
94599
94600   jresult = (unsigned long)result;
94601   return jresult;
94602 }
94603
94604
94605 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94606   unsigned long jresult ;
94607   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94608   std::vector< Dali::Actor >::size_type result;
94609
94610   arg1 = (std::vector< Dali::Actor > *)jarg1;
94611   {
94612     try {
94613       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94614     } catch (std::out_of_range& e) {
94615       {
94616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94617       };
94618     } catch (std::exception& e) {
94619       {
94620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94621       };
94622     } catch (Dali::DaliException e) {
94623       {
94624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94625       };
94626     } catch (...) {
94627       {
94628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94629       };
94630     }
94631   }
94632
94633   jresult = (unsigned long)result;
94634   return jresult;
94635 }
94636
94637
94638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94639   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94640   std::vector< Dali::Actor >::size_type arg2 ;
94641
94642   arg1 = (std::vector< Dali::Actor > *)jarg1;
94643   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94644   {
94645     try {
94646       (arg1)->reserve(arg2);
94647     } catch (std::out_of_range& e) {
94648       {
94649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94650       };
94651     } catch (std::exception& e) {
94652       {
94653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94654       };
94655     } catch (Dali::DaliException e) {
94656       {
94657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94658       };
94659     } catch (...) {
94660       {
94661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94662       };
94663     }
94664   }
94665
94666 }
94667
94668
94669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94670   void * jresult ;
94671   std::vector< Dali::Actor > *result = 0 ;
94672
94673   {
94674     try {
94675       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94676     } catch (std::out_of_range& e) {
94677       {
94678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94679       };
94680     } catch (std::exception& e) {
94681       {
94682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94683       };
94684     } catch (Dali::DaliException e) {
94685       {
94686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94687       };
94688     } catch (...) {
94689       {
94690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94691       };
94692     }
94693   }
94694
94695   jresult = (void *)result;
94696   return jresult;
94697 }
94698
94699
94700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94701   void * jresult ;
94702   std::vector< Dali::Actor > *arg1 = 0 ;
94703   std::vector< Dali::Actor > *result = 0 ;
94704
94705   arg1 = (std::vector< Dali::Actor > *)jarg1;
94706   if (!arg1) {
94707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94708     return 0;
94709   }
94710   {
94711     try {
94712       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94713     } catch (std::out_of_range& e) {
94714       {
94715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94716       };
94717     } catch (std::exception& e) {
94718       {
94719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94720       };
94721     } catch (Dali::DaliException e) {
94722       {
94723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94724       };
94725     } catch (...) {
94726       {
94727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94728       };
94729     }
94730   }
94731
94732   jresult = (void *)result;
94733   return jresult;
94734 }
94735
94736
94737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94738   void * jresult ;
94739   int arg1 ;
94740   std::vector< Dali::Actor > *result = 0 ;
94741
94742   arg1 = (int)jarg1;
94743   {
94744     try {
94745       try {
94746         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94747       }
94748       catch(std::out_of_range &_e) {
94749         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94750         return 0;
94751       }
94752
94753     } catch (std::out_of_range& e) {
94754       {
94755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94756       };
94757     } catch (std::exception& e) {
94758       {
94759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94760       };
94761     } catch (Dali::DaliException e) {
94762       {
94763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94764       };
94765     } catch (...) {
94766       {
94767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94768       };
94769     }
94770   }
94771
94772   jresult = (void *)result;
94773   return jresult;
94774 }
94775
94776
94777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94778   void * jresult ;
94779   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94780   int arg2 ;
94781   Dali::Actor result;
94782
94783   arg1 = (std::vector< Dali::Actor > *)jarg1;
94784   arg2 = (int)jarg2;
94785   {
94786     try {
94787       try {
94788         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94789       }
94790       catch(std::out_of_range &_e) {
94791         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94792         return 0;
94793       }
94794
94795     } catch (std::out_of_range& e) {
94796       {
94797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94798       };
94799     } catch (std::exception& e) {
94800       {
94801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94802       };
94803     } catch (Dali::DaliException e) {
94804       {
94805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94806       };
94807     } catch (...) {
94808       {
94809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94810       };
94811     }
94812   }
94813
94814   jresult = new Dali::Actor((const Dali::Actor &)result);
94815   return jresult;
94816 }
94817
94818
94819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94820   void * jresult ;
94821   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94822   int arg2 ;
94823   Dali::Actor *result = 0 ;
94824
94825   arg1 = (std::vector< Dali::Actor > *)jarg1;
94826   arg2 = (int)jarg2;
94827   {
94828     try {
94829       try {
94830         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94831       }
94832       catch(std::out_of_range &_e) {
94833         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94834         return 0;
94835       }
94836
94837     } catch (std::out_of_range& e) {
94838       {
94839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94840       };
94841     } catch (std::exception& e) {
94842       {
94843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94844       };
94845     } catch (Dali::DaliException e) {
94846       {
94847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94848       };
94849     } catch (...) {
94850       {
94851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94852       };
94853     }
94854   }
94855
94856   jresult = (void *)result;
94857   return jresult;
94858 }
94859
94860
94861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94862   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94863   int arg2 ;
94864   Dali::Actor *arg3 = 0 ;
94865
94866   arg1 = (std::vector< Dali::Actor > *)jarg1;
94867   arg2 = (int)jarg2;
94868   arg3 = (Dali::Actor *)jarg3;
94869   if (!arg3) {
94870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94871     return ;
94872   }
94873   {
94874     try {
94875       try {
94876         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94877       }
94878       catch(std::out_of_range &_e) {
94879         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94880         return ;
94881       }
94882
94883     } catch (std::out_of_range& e) {
94884       {
94885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94886       };
94887     } catch (std::exception& e) {
94888       {
94889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94890       };
94891     } catch (Dali::DaliException e) {
94892       {
94893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94894       };
94895     } catch (...) {
94896       {
94897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94898       };
94899     }
94900   }
94901
94902 }
94903
94904
94905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94906   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94907   std::vector< Dali::Actor > *arg2 = 0 ;
94908
94909   arg1 = (std::vector< Dali::Actor > *)jarg1;
94910   arg2 = (std::vector< Dali::Actor > *)jarg2;
94911   if (!arg2) {
94912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94913     return ;
94914   }
94915   {
94916     try {
94917       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
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_GetRange(void * jarg1, int jarg2, int jarg3) {
94941   void * jresult ;
94942   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94943   int arg2 ;
94944   int arg3 ;
94945   std::vector< Dali::Actor > *result = 0 ;
94946
94947   arg1 = (std::vector< Dali::Actor > *)jarg1;
94948   arg2 = (int)jarg2;
94949   arg3 = (int)jarg3;
94950   {
94951     try {
94952       try {
94953         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94954       }
94955       catch(std::out_of_range &_e) {
94956         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94957         return 0;
94958       }
94959       catch(std::invalid_argument &_e) {
94960         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94961         return 0;
94962       }
94963
94964     } catch (std::out_of_range& e) {
94965       {
94966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94967       };
94968     } catch (std::exception& e) {
94969       {
94970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94971       };
94972     } catch (Dali::DaliException e) {
94973       {
94974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94975       };
94976     } catch (...) {
94977       {
94978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94979       };
94980     }
94981   }
94982
94983   jresult = (void *)result;
94984   return jresult;
94985 }
94986
94987
94988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94989   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94990   int arg2 ;
94991   Dali::Actor *arg3 = 0 ;
94992
94993   arg1 = (std::vector< Dali::Actor > *)jarg1;
94994   arg2 = (int)jarg2;
94995   arg3 = (Dali::Actor *)jarg3;
94996   if (!arg3) {
94997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94998     return ;
94999   }
95000   {
95001     try {
95002       try {
95003         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95004       }
95005       catch(std::out_of_range &_e) {
95006         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95007         return ;
95008       }
95009
95010     } catch (std::out_of_range& e) {
95011       {
95012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95013       };
95014     } catch (std::exception& e) {
95015       {
95016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95017       };
95018     } catch (Dali::DaliException e) {
95019       {
95020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95021       };
95022     } catch (...) {
95023       {
95024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95025       };
95026     }
95027   }
95028
95029 }
95030
95031
95032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95033   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95034   int arg2 ;
95035   std::vector< Dali::Actor > *arg3 = 0 ;
95036
95037   arg1 = (std::vector< Dali::Actor > *)jarg1;
95038   arg2 = (int)jarg2;
95039   arg3 = (std::vector< Dali::Actor > *)jarg3;
95040   if (!arg3) {
95041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95042     return ;
95043   }
95044   {
95045     try {
95046       try {
95047         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95048       }
95049       catch(std::out_of_range &_e) {
95050         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95051         return ;
95052       }
95053
95054     } catch (std::out_of_range& e) {
95055       {
95056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95057       };
95058     } catch (std::exception& e) {
95059       {
95060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95061       };
95062     } catch (Dali::DaliException e) {
95063       {
95064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95065       };
95066     } catch (...) {
95067       {
95068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95069       };
95070     }
95071   }
95072
95073 }
95074
95075
95076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95077   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95078   int arg2 ;
95079
95080   arg1 = (std::vector< Dali::Actor > *)jarg1;
95081   arg2 = (int)jarg2;
95082   {
95083     try {
95084       try {
95085         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95086       }
95087       catch(std::out_of_range &_e) {
95088         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95089         return ;
95090       }
95091
95092     } catch (std::out_of_range& e) {
95093       {
95094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95095       };
95096     } catch (std::exception& e) {
95097       {
95098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95099       };
95100     } catch (Dali::DaliException e) {
95101       {
95102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95103       };
95104     } catch (...) {
95105       {
95106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95107       };
95108     }
95109   }
95110
95111 }
95112
95113
95114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95115   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95116   int arg2 ;
95117   int arg3 ;
95118
95119   arg1 = (std::vector< Dali::Actor > *)jarg1;
95120   arg2 = (int)jarg2;
95121   arg3 = (int)jarg3;
95122   {
95123     try {
95124       try {
95125         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95126       }
95127       catch(std::out_of_range &_e) {
95128         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95129         return ;
95130       }
95131       catch(std::invalid_argument &_e) {
95132         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95133         return ;
95134       }
95135
95136     } catch (std::out_of_range& e) {
95137       {
95138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95139       };
95140     } catch (std::exception& e) {
95141       {
95142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95143       };
95144     } catch (Dali::DaliException e) {
95145       {
95146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95147       };
95148     } catch (...) {
95149       {
95150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95151       };
95152     }
95153   }
95154
95155 }
95156
95157
95158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95159   void * jresult ;
95160   Dali::Actor *arg1 = 0 ;
95161   int arg2 ;
95162   std::vector< Dali::Actor > *result = 0 ;
95163
95164   arg1 = (Dali::Actor *)jarg1;
95165   if (!arg1) {
95166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95167     return 0;
95168   }
95169   arg2 = (int)jarg2;
95170   {
95171     try {
95172       try {
95173         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95174       }
95175       catch(std::out_of_range &_e) {
95176         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95177         return 0;
95178       }
95179
95180     } catch (std::out_of_range& e) {
95181       {
95182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95183       };
95184     } catch (std::exception& e) {
95185       {
95186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95187       };
95188     } catch (Dali::DaliException e) {
95189       {
95190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95191       };
95192     } catch (...) {
95193       {
95194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95195       };
95196     }
95197   }
95198
95199   jresult = (void *)result;
95200   return jresult;
95201 }
95202
95203
95204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95205   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95206
95207   arg1 = (std::vector< Dali::Actor > *)jarg1;
95208   {
95209     try {
95210       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95211     } catch (std::out_of_range& e) {
95212       {
95213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95214       };
95215     } catch (std::exception& e) {
95216       {
95217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95218       };
95219     } catch (Dali::DaliException e) {
95220       {
95221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95222       };
95223     } catch (...) {
95224       {
95225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95226       };
95227     }
95228   }
95229
95230 }
95231
95232
95233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95234   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95235   int arg2 ;
95236   int arg3 ;
95237
95238   arg1 = (std::vector< Dali::Actor > *)jarg1;
95239   arg2 = (int)jarg2;
95240   arg3 = (int)jarg3;
95241   {
95242     try {
95243       try {
95244         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95245       }
95246       catch(std::out_of_range &_e) {
95247         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95248         return ;
95249       }
95250       catch(std::invalid_argument &_e) {
95251         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95252         return ;
95253       }
95254
95255     } catch (std::out_of_range& e) {
95256       {
95257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95258       };
95259     } catch (std::exception& e) {
95260       {
95261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95262       };
95263     } catch (Dali::DaliException e) {
95264       {
95265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95266       };
95267     } catch (...) {
95268       {
95269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95270       };
95271     }
95272   }
95273
95274 }
95275
95276
95277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95278   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95279   int arg2 ;
95280   std::vector< Dali::Actor > *arg3 = 0 ;
95281
95282   arg1 = (std::vector< Dali::Actor > *)jarg1;
95283   arg2 = (int)jarg2;
95284   arg3 = (std::vector< Dali::Actor > *)jarg3;
95285   if (!arg3) {
95286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95287     return ;
95288   }
95289   {
95290     try {
95291       try {
95292         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95293       }
95294       catch(std::out_of_range &_e) {
95295         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95296         return ;
95297       }
95298
95299     } catch (std::out_of_range& e) {
95300       {
95301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95302       };
95303     } catch (std::exception& e) {
95304       {
95305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95306       };
95307     } catch (Dali::DaliException e) {
95308       {
95309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95310       };
95311     } catch (...) {
95312       {
95313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95314       };
95315     }
95316   }
95317
95318 }
95319
95320
95321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95322   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95323
95324   arg1 = (std::vector< Dali::Actor > *)jarg1;
95325   {
95326     try {
95327       delete arg1;
95328     } catch (std::out_of_range& e) {
95329       {
95330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95331       };
95332     } catch (std::exception& e) {
95333       {
95334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95335       };
95336     } catch (Dali::DaliException e) {
95337       {
95338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95339       };
95340     } catch (...) {
95341       {
95342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95343       };
95344     }
95345   }
95346
95347 }
95348
95349
95350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95351   unsigned int jresult ;
95352   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95353   bool result;
95354
95355   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95356   {
95357     try {
95358       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95359     } catch (std::out_of_range& e) {
95360       {
95361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95362       };
95363     } catch (std::exception& e) {
95364       {
95365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95366       };
95367     } catch (Dali::DaliException e) {
95368       {
95369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95370       };
95371     } catch (...) {
95372       {
95373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95374       };
95375     }
95376   }
95377
95378   jresult = result;
95379   return jresult;
95380 }
95381
95382
95383 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95384   unsigned long jresult ;
95385   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95386   std::size_t result;
95387
95388   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95389   {
95390     try {
95391       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95392     } catch (std::out_of_range& e) {
95393       {
95394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95395       };
95396     } catch (std::exception& e) {
95397       {
95398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95399       };
95400     } catch (Dali::DaliException e) {
95401       {
95402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95403       };
95404     } catch (...) {
95405       {
95406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95407       };
95408     }
95409   }
95410
95411   jresult = (unsigned long)result;
95412   return jresult;
95413 }
95414
95415
95416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95417   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95418   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95419
95420   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95421   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95422   {
95423     try {
95424       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95425     } catch (std::out_of_range& e) {
95426       {
95427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95428       };
95429     } catch (std::exception& e) {
95430       {
95431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95432       };
95433     } catch (Dali::DaliException e) {
95434       {
95435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95436       };
95437     } catch (...) {
95438       {
95439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95440       };
95441     }
95442   }
95443
95444 }
95445
95446
95447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95448   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95449   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95450
95451   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95452   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95453   {
95454     try {
95455       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95456     } catch (std::out_of_range& e) {
95457       {
95458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95459       };
95460     } catch (std::exception& e) {
95461       {
95462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95463       };
95464     } catch (Dali::DaliException e) {
95465       {
95466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95467       };
95468     } catch (...) {
95469       {
95470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95471       };
95472     }
95473   }
95474
95475 }
95476
95477
95478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95479   unsigned int jresult ;
95480   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95481   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95482   bool result;
95483
95484   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95485   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95486   if (!arg2) {
95487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95488     return 0;
95489   }
95490   {
95491     try {
95492       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95493     } catch (std::out_of_range& e) {
95494       {
95495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95496       };
95497     } catch (std::exception& e) {
95498       {
95499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95500       };
95501     } catch (Dali::DaliException e) {
95502       {
95503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95504       };
95505     } catch (...) {
95506       {
95507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95508       };
95509     }
95510   }
95511
95512   jresult = result;
95513   return jresult;
95514 }
95515
95516
95517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95518   void * jresult ;
95519   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95520
95521   {
95522     try {
95523       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95524     } catch (std::out_of_range& e) {
95525       {
95526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95527       };
95528     } catch (std::exception& e) {
95529       {
95530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95531       };
95532     } catch (Dali::DaliException e) {
95533       {
95534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95535       };
95536     } catch (...) {
95537       {
95538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95539       };
95540     }
95541   }
95542
95543   jresult = (void *)result;
95544   return jresult;
95545 }
95546
95547
95548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95549   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95550
95551   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95552   {
95553     try {
95554       delete arg1;
95555     } catch (std::out_of_range& e) {
95556       {
95557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95558       };
95559     } catch (std::exception& e) {
95560       {
95561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95562       };
95563     } catch (Dali::DaliException e) {
95564       {
95565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95566       };
95567     } catch (...) {
95568       {
95569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95570       };
95571     }
95572   }
95573
95574 }
95575
95576
95577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95578   unsigned int jresult ;
95579   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95580   bool result;
95581
95582   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95583   {
95584     try {
95585       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);
95586     } catch (std::out_of_range& e) {
95587       {
95588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95589       };
95590     } catch (std::exception& e) {
95591       {
95592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95593       };
95594     } catch (Dali::DaliException e) {
95595       {
95596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95597       };
95598     } catch (...) {
95599       {
95600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95601       };
95602     }
95603   }
95604
95605   jresult = result;
95606   return jresult;
95607 }
95608
95609
95610 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95611   unsigned long jresult ;
95612   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95613   std::size_t result;
95614
95615   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95616   {
95617     try {
95618       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);
95619     } catch (std::out_of_range& e) {
95620       {
95621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95622       };
95623     } catch (std::exception& e) {
95624       {
95625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95626       };
95627     } catch (Dali::DaliException e) {
95628       {
95629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95630       };
95631     } catch (...) {
95632       {
95633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95634       };
95635     }
95636   }
95637
95638   jresult = (unsigned long)result;
95639   return jresult;
95640 }
95641
95642
95643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95644   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95645   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95646
95647   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95648   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95649   {
95650     try {
95651       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95652     } catch (std::out_of_range& e) {
95653       {
95654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95655       };
95656     } catch (std::exception& e) {
95657       {
95658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95659       };
95660     } catch (Dali::DaliException e) {
95661       {
95662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95663       };
95664     } catch (...) {
95665       {
95666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95667       };
95668     }
95669   }
95670
95671 }
95672
95673
95674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95675   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95676   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95677
95678   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95679   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95680   {
95681     try {
95682       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95683     } catch (std::out_of_range& e) {
95684       {
95685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95686       };
95687     } catch (std::exception& e) {
95688       {
95689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95690       };
95691     } catch (Dali::DaliException e) {
95692       {
95693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95694       };
95695     } catch (...) {
95696       {
95697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95698       };
95699     }
95700   }
95701
95702 }
95703
95704
95705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95706   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95707   Dali::Actor arg2 ;
95708   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95709   Dali::Actor *argp2 ;
95710
95711   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95712   argp2 = (Dali::Actor *)jarg2;
95713   if (!argp2) {
95714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95715     return ;
95716   }
95717   arg2 = *argp2;
95718   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95719   {
95720     try {
95721       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95722     } catch (std::out_of_range& e) {
95723       {
95724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95725       };
95726     } catch (std::exception& e) {
95727       {
95728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95729       };
95730     } catch (Dali::DaliException e) {
95731       {
95732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95733       };
95734     } catch (...) {
95735       {
95736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95737       };
95738     }
95739   }
95740
95741 }
95742
95743
95744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95745   void * jresult ;
95746   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95747
95748   {
95749     try {
95750       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95751     } catch (std::out_of_range& e) {
95752       {
95753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95754       };
95755     } catch (std::exception& e) {
95756       {
95757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95758       };
95759     } catch (Dali::DaliException e) {
95760       {
95761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95762       };
95763     } catch (...) {
95764       {
95765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95766       };
95767     }
95768   }
95769
95770   jresult = (void *)result;
95771   return jresult;
95772 }
95773
95774
95775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95776   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95777
95778   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95779   {
95780     try {
95781       delete arg1;
95782     } catch (std::out_of_range& e) {
95783       {
95784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95785       };
95786     } catch (std::exception& e) {
95787       {
95788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95789       };
95790     } catch (Dali::DaliException e) {
95791       {
95792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95793       };
95794     } catch (...) {
95795       {
95796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95797       };
95798     }
95799   }
95800
95801 }
95802
95803
95804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95805   unsigned int jresult ;
95806   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95807   bool result;
95808
95809   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95810   {
95811     try {
95812       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95813     } catch (std::out_of_range& e) {
95814       {
95815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95816       };
95817     } catch (std::exception& e) {
95818       {
95819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95820       };
95821     } catch (Dali::DaliException e) {
95822       {
95823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95824       };
95825     } catch (...) {
95826       {
95827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95828       };
95829     }
95830   }
95831
95832   jresult = result;
95833   return jresult;
95834 }
95835
95836
95837 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95838   unsigned long jresult ;
95839   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95840   std::size_t result;
95841
95842   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95843   {
95844     try {
95845       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95846     } catch (std::out_of_range& e) {
95847       {
95848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95849       };
95850     } catch (std::exception& e) {
95851       {
95852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95853       };
95854     } catch (Dali::DaliException e) {
95855       {
95856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95857       };
95858     } catch (...) {
95859       {
95860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95861       };
95862     }
95863   }
95864
95865   jresult = (unsigned long)result;
95866   return jresult;
95867 }
95868
95869
95870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95871   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95872   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95873
95874   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95875   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95876   {
95877     try {
95878       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95879     } catch (std::out_of_range& e) {
95880       {
95881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95882       };
95883     } catch (std::exception& e) {
95884       {
95885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95886       };
95887     } catch (Dali::DaliException e) {
95888       {
95889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95890       };
95891     } catch (...) {
95892       {
95893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95894       };
95895     }
95896   }
95897
95898 }
95899
95900
95901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95902   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95903   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95904
95905   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95906   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95907   {
95908     try {
95909       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95910     } catch (std::out_of_range& e) {
95911       {
95912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95913       };
95914     } catch (std::exception& e) {
95915       {
95916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95917       };
95918     } catch (Dali::DaliException e) {
95919       {
95920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95921       };
95922     } catch (...) {
95923       {
95924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95925       };
95926     }
95927   }
95928
95929 }
95930
95931
95932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95933   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95934   Dali::Actor arg2 ;
95935   Dali::Actor arg3 ;
95936   Dali::Actor *argp2 ;
95937   Dali::Actor *argp3 ;
95938
95939   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95940   argp2 = (Dali::Actor *)jarg2;
95941   if (!argp2) {
95942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95943     return ;
95944   }
95945   arg2 = *argp2;
95946   argp3 = (Dali::Actor *)jarg3;
95947   if (!argp3) {
95948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95949     return ;
95950   }
95951   arg3 = *argp3;
95952   {
95953     try {
95954       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95955     } catch (std::out_of_range& e) {
95956       {
95957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95958       };
95959     } catch (std::exception& e) {
95960       {
95961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95962       };
95963     } catch (Dali::DaliException e) {
95964       {
95965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95966       };
95967     } catch (...) {
95968       {
95969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95970       };
95971     }
95972   }
95973
95974 }
95975
95976
95977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95978   void * jresult ;
95979   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95980
95981   {
95982     try {
95983       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95984     } catch (std::out_of_range& e) {
95985       {
95986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95987       };
95988     } catch (std::exception& e) {
95989       {
95990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95991       };
95992     } catch (Dali::DaliException e) {
95993       {
95994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95995       };
95996     } catch (...) {
95997       {
95998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95999       };
96000     }
96001   }
96002
96003   jresult = (void *)result;
96004   return jresult;
96005 }
96006
96007
96008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96009   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96010
96011   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96012   {
96013     try {
96014       delete arg1;
96015     } catch (std::out_of_range& e) {
96016       {
96017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96018       };
96019     } catch (std::exception& e) {
96020       {
96021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96022       };
96023     } catch (Dali::DaliException e) {
96024       {
96025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96026       };
96027     } catch (...) {
96028       {
96029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96030       };
96031     }
96032   }
96033
96034 }
96035
96036
96037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96038   unsigned int jresult ;
96039   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96040   bool result;
96041
96042   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96043   {
96044     try {
96045       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96046     } catch (std::out_of_range& e) {
96047       {
96048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96049       };
96050     } catch (std::exception& e) {
96051       {
96052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96053       };
96054     } catch (Dali::DaliException e) {
96055       {
96056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96057       };
96058     } catch (...) {
96059       {
96060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96061       };
96062     }
96063   }
96064
96065   jresult = result;
96066   return jresult;
96067 }
96068
96069
96070 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96071   unsigned long jresult ;
96072   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96073   std::size_t result;
96074
96075   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96076   {
96077     try {
96078       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96079     } catch (std::out_of_range& e) {
96080       {
96081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96082       };
96083     } catch (std::exception& e) {
96084       {
96085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96086       };
96087     } catch (Dali::DaliException e) {
96088       {
96089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96090       };
96091     } catch (...) {
96092       {
96093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96094       };
96095     }
96096   }
96097
96098   jresult = (unsigned long)result;
96099   return jresult;
96100 }
96101
96102
96103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96104   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96105   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96106
96107   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96108   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96109   {
96110     try {
96111       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96112     } catch (std::out_of_range& e) {
96113       {
96114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96115       };
96116     } catch (std::exception& e) {
96117       {
96118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96119       };
96120     } catch (Dali::DaliException e) {
96121       {
96122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96123       };
96124     } catch (...) {
96125       {
96126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96127       };
96128     }
96129   }
96130
96131 }
96132
96133
96134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96135   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96136   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96137
96138   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96139   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96140   {
96141     try {
96142       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96143     } catch (std::out_of_range& e) {
96144       {
96145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96146       };
96147     } catch (std::exception& e) {
96148       {
96149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96150       };
96151     } catch (Dali::DaliException e) {
96152       {
96153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96154       };
96155     } catch (...) {
96156       {
96157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96158       };
96159     }
96160   }
96161
96162 }
96163
96164
96165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96166   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96167   Dali::Actor arg2 ;
96168   bool arg3 ;
96169   Dali::Actor *argp2 ;
96170
96171   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96172   argp2 = (Dali::Actor *)jarg2;
96173   if (!argp2) {
96174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96175     return ;
96176   }
96177   arg2 = *argp2;
96178   arg3 = jarg3 ? true : false;
96179   {
96180     try {
96181       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96182     } catch (std::out_of_range& e) {
96183       {
96184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96185       };
96186     } catch (std::exception& e) {
96187       {
96188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96189       };
96190     } catch (Dali::DaliException e) {
96191       {
96192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96193       };
96194     } catch (...) {
96195       {
96196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96197       };
96198     }
96199   }
96200
96201 }
96202
96203
96204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96205   void * jresult ;
96206   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96207
96208   {
96209     try {
96210       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96211     } catch (std::out_of_range& e) {
96212       {
96213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96214       };
96215     } catch (std::exception& e) {
96216       {
96217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96218       };
96219     } catch (Dali::DaliException e) {
96220       {
96221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96222       };
96223     } catch (...) {
96224       {
96225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96226       };
96227     }
96228   }
96229
96230   jresult = (void *)result;
96231   return jresult;
96232 }
96233
96234
96235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96236   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96237
96238   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96239   {
96240     try {
96241       delete arg1;
96242     } catch (std::out_of_range& e) {
96243       {
96244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96245       };
96246     } catch (std::exception& e) {
96247       {
96248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96249       };
96250     } catch (Dali::DaliException e) {
96251       {
96252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96253       };
96254     } catch (...) {
96255       {
96256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96257       };
96258     }
96259   }
96260
96261 }
96262
96263
96264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96265   unsigned int jresult ;
96266   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96267   bool result;
96268
96269   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96270   {
96271     try {
96272       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);
96273     } catch (std::out_of_range& e) {
96274       {
96275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96276       };
96277     } catch (std::exception& e) {
96278       {
96279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96280       };
96281     } catch (Dali::DaliException e) {
96282       {
96283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96284       };
96285     } catch (...) {
96286       {
96287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96288       };
96289     }
96290   }
96291
96292   jresult = result;
96293   return jresult;
96294 }
96295
96296
96297 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96298   unsigned long jresult ;
96299   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96300   std::size_t result;
96301
96302   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96303   {
96304     try {
96305       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);
96306     } catch (std::out_of_range& e) {
96307       {
96308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96309       };
96310     } catch (std::exception& e) {
96311       {
96312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96313       };
96314     } catch (Dali::DaliException e) {
96315       {
96316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96317       };
96318     } catch (...) {
96319       {
96320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96321       };
96322     }
96323   }
96324
96325   jresult = (unsigned long)result;
96326   return jresult;
96327 }
96328
96329
96330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96331   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96332   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96333
96334   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96335   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96336   {
96337     try {
96338       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96339     } catch (std::out_of_range& e) {
96340       {
96341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96342       };
96343     } catch (std::exception& e) {
96344       {
96345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96346       };
96347     } catch (Dali::DaliException e) {
96348       {
96349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96350       };
96351     } catch (...) {
96352       {
96353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96354       };
96355     }
96356   }
96357
96358 }
96359
96360
96361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96362   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96363   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96364
96365   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96366   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96367   {
96368     try {
96369       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96370     } catch (std::out_of_range& e) {
96371       {
96372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96373       };
96374     } catch (std::exception& e) {
96375       {
96376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96377       };
96378     } catch (Dali::DaliException e) {
96379       {
96380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96381       };
96382     } catch (...) {
96383       {
96384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96385       };
96386     }
96387   }
96388
96389 }
96390
96391
96392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96393   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96394   Dali::Toolkit::StyleManager arg2 ;
96395   Dali::StyleChange::Type arg3 ;
96396   Dali::Toolkit::StyleManager *argp2 ;
96397
96398   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96399   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96400   if (!argp2) {
96401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96402     return ;
96403   }
96404   arg2 = *argp2;
96405   arg3 = (Dali::StyleChange::Type)jarg3;
96406   {
96407     try {
96408       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96409     } catch (std::out_of_range& e) {
96410       {
96411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96412       };
96413     } catch (std::exception& e) {
96414       {
96415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96416       };
96417     } catch (Dali::DaliException e) {
96418       {
96419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96420       };
96421     } catch (...) {
96422       {
96423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96424       };
96425     }
96426   }
96427
96428 }
96429
96430
96431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96432   void * jresult ;
96433   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96434
96435   {
96436     try {
96437       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96438     } catch (std::out_of_range& e) {
96439       {
96440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96441       };
96442     } catch (std::exception& e) {
96443       {
96444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96445       };
96446     } catch (Dali::DaliException e) {
96447       {
96448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96449       };
96450     } catch (...) {
96451       {
96452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96453       };
96454     }
96455   }
96456
96457   jresult = (void *)result;
96458   return jresult;
96459 }
96460
96461
96462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96463   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96464
96465   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96466   {
96467     try {
96468       delete arg1;
96469     } catch (std::out_of_range& e) {
96470       {
96471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96472       };
96473     } catch (std::exception& e) {
96474       {
96475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96476       };
96477     } catch (Dali::DaliException e) {
96478       {
96479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96480       };
96481     } catch (...) {
96482       {
96483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96484       };
96485     }
96486   }
96487
96488 }
96489
96490
96491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96492   unsigned int jresult ;
96493   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96494   bool result;
96495
96496   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96497   {
96498     try {
96499       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96500     } catch (std::out_of_range& e) {
96501       {
96502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96503       };
96504     } catch (std::exception& e) {
96505       {
96506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96507       };
96508     } catch (Dali::DaliException e) {
96509       {
96510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96511       };
96512     } catch (...) {
96513       {
96514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96515       };
96516     }
96517   }
96518
96519   jresult = result;
96520   return jresult;
96521 }
96522
96523
96524 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96525   unsigned long jresult ;
96526   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96527   std::size_t result;
96528
96529   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96530   {
96531     try {
96532       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96533     } catch (std::out_of_range& e) {
96534       {
96535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96536       };
96537     } catch (std::exception& e) {
96538       {
96539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96540       };
96541     } catch (Dali::DaliException e) {
96542       {
96543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96544       };
96545     } catch (...) {
96546       {
96547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96548       };
96549     }
96550   }
96551
96552   jresult = (unsigned long)result;
96553   return jresult;
96554 }
96555
96556
96557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96558   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96559   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96560
96561   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96562   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96563   {
96564     try {
96565       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96566     } catch (std::out_of_range& e) {
96567       {
96568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96569       };
96570     } catch (std::exception& e) {
96571       {
96572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96573       };
96574     } catch (Dali::DaliException e) {
96575       {
96576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96577       };
96578     } catch (...) {
96579       {
96580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96581       };
96582     }
96583   }
96584
96585 }
96586
96587
96588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96589   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96590   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96591
96592   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96593   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96594   {
96595     try {
96596       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96597     } catch (std::out_of_range& e) {
96598       {
96599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96600       };
96601     } catch (std::exception& e) {
96602       {
96603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96604       };
96605     } catch (Dali::DaliException e) {
96606       {
96607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96608       };
96609     } catch (...) {
96610       {
96611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96612       };
96613     }
96614   }
96615
96616 }
96617
96618
96619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96620   unsigned int jresult ;
96621   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96622   Dali::Toolkit::Button arg2 ;
96623   Dali::Toolkit::Button *argp2 ;
96624   bool result;
96625
96626   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96627   argp2 = (Dali::Toolkit::Button *)jarg2;
96628   if (!argp2) {
96629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96630     return 0;
96631   }
96632   arg2 = *argp2;
96633   {
96634     try {
96635       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96636     } catch (std::out_of_range& e) {
96637       {
96638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96639       };
96640     } catch (std::exception& e) {
96641       {
96642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96643       };
96644     } catch (Dali::DaliException e) {
96645       {
96646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96647       };
96648     } catch (...) {
96649       {
96650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96651       };
96652     }
96653   }
96654
96655   jresult = result;
96656   return jresult;
96657 }
96658
96659
96660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96661   void * jresult ;
96662   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96663
96664   {
96665     try {
96666       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96667     } catch (std::out_of_range& e) {
96668       {
96669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96670       };
96671     } catch (std::exception& e) {
96672       {
96673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96674       };
96675     } catch (Dali::DaliException e) {
96676       {
96677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96678       };
96679     } catch (...) {
96680       {
96681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96682       };
96683     }
96684   }
96685
96686   jresult = (void *)result;
96687   return jresult;
96688 }
96689
96690
96691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96692   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96693
96694   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96695   {
96696     try {
96697       delete arg1;
96698     } catch (std::out_of_range& e) {
96699       {
96700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96701       };
96702     } catch (std::exception& e) {
96703       {
96704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96705       };
96706     } catch (Dali::DaliException e) {
96707       {
96708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96709       };
96710     } catch (...) {
96711       {
96712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96713       };
96714     }
96715   }
96716
96717 }
96718
96719
96720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96721   unsigned int jresult ;
96722   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96723   bool result;
96724
96725   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96726   {
96727     try {
96728       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96729     } catch (std::out_of_range& e) {
96730       {
96731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96732       };
96733     } catch (std::exception& e) {
96734       {
96735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96736       };
96737     } catch (Dali::DaliException e) {
96738       {
96739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96740       };
96741     } catch (...) {
96742       {
96743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96744       };
96745     }
96746   }
96747
96748   jresult = result;
96749   return jresult;
96750 }
96751
96752
96753 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96754   unsigned long jresult ;
96755   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96756   std::size_t result;
96757
96758   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96759   {
96760     try {
96761       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96762     } catch (std::out_of_range& e) {
96763       {
96764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96765       };
96766     } catch (std::exception& e) {
96767       {
96768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96769       };
96770     } catch (Dali::DaliException e) {
96771       {
96772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96773       };
96774     } catch (...) {
96775       {
96776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96777       };
96778     }
96779   }
96780
96781   jresult = (unsigned long)result;
96782   return jresult;
96783 }
96784
96785
96786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96787   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96788   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96789
96790   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96791   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96792   {
96793     try {
96794       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96795     } catch (std::out_of_range& e) {
96796       {
96797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96798       };
96799     } catch (std::exception& e) {
96800       {
96801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96802       };
96803     } catch (Dali::DaliException e) {
96804       {
96805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96806       };
96807     } catch (...) {
96808       {
96809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96810       };
96811     }
96812   }
96813
96814 }
96815
96816
96817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96818   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96819   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96820
96821   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96822   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96823   {
96824     try {
96825       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96826     } catch (std::out_of_range& e) {
96827       {
96828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96829       };
96830     } catch (std::exception& e) {
96831       {
96832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96833       };
96834     } catch (Dali::DaliException e) {
96835       {
96836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96837       };
96838     } catch (...) {
96839       {
96840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96841       };
96842     }
96843   }
96844
96845 }
96846
96847
96848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96849   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96850   Dali::Toolkit::GaussianBlurView arg2 ;
96851   Dali::Toolkit::GaussianBlurView *argp2 ;
96852
96853   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96854   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96855   if (!argp2) {
96856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96857     return ;
96858   }
96859   arg2 = *argp2;
96860   {
96861     try {
96862       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96863     } catch (std::out_of_range& e) {
96864       {
96865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96866       };
96867     } catch (std::exception& e) {
96868       {
96869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96870       };
96871     } catch (Dali::DaliException e) {
96872       {
96873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96874       };
96875     } catch (...) {
96876       {
96877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96878       };
96879     }
96880   }
96881
96882 }
96883
96884
96885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96886   void * jresult ;
96887   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96888
96889   {
96890     try {
96891       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96892     } catch (std::out_of_range& e) {
96893       {
96894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96895       };
96896     } catch (std::exception& e) {
96897       {
96898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96899       };
96900     } catch (Dali::DaliException e) {
96901       {
96902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96903       };
96904     } catch (...) {
96905       {
96906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96907       };
96908     }
96909   }
96910
96911   jresult = (void *)result;
96912   return jresult;
96913 }
96914
96915
96916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96917   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96918
96919   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96920   {
96921     try {
96922       delete arg1;
96923     } catch (std::out_of_range& e) {
96924       {
96925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96926       };
96927     } catch (std::exception& e) {
96928       {
96929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96930       };
96931     } catch (Dali::DaliException e) {
96932       {
96933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96934       };
96935     } catch (...) {
96936       {
96937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96938       };
96939     }
96940   }
96941
96942 }
96943
96944
96945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96946   unsigned int jresult ;
96947   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96948   bool result;
96949
96950   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96951   {
96952     try {
96953       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);
96954     } catch (std::out_of_range& e) {
96955       {
96956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96957       };
96958     } catch (std::exception& e) {
96959       {
96960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96961       };
96962     } catch (Dali::DaliException e) {
96963       {
96964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96965       };
96966     } catch (...) {
96967       {
96968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96969       };
96970     }
96971   }
96972
96973   jresult = result;
96974   return jresult;
96975 }
96976
96977
96978 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96979   unsigned long jresult ;
96980   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96981   std::size_t result;
96982
96983   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96984   {
96985     try {
96986       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);
96987     } catch (std::out_of_range& e) {
96988       {
96989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96990       };
96991     } catch (std::exception& e) {
96992       {
96993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96994       };
96995     } catch (Dali::DaliException e) {
96996       {
96997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96998       };
96999     } catch (...) {
97000       {
97001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97002       };
97003     }
97004   }
97005
97006   jresult = (unsigned long)result;
97007   return jresult;
97008 }
97009
97010
97011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97012   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97013   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97014
97015   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97016   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97017   {
97018     try {
97019       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97020     } catch (std::out_of_range& e) {
97021       {
97022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97023       };
97024     } catch (std::exception& e) {
97025       {
97026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97027       };
97028     } catch (Dali::DaliException e) {
97029       {
97030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97031       };
97032     } catch (...) {
97033       {
97034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97035       };
97036     }
97037   }
97038
97039 }
97040
97041
97042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97043   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97044   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97045
97046   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97047   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97048   {
97049     try {
97050       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97051     } catch (std::out_of_range& e) {
97052       {
97053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97054       };
97055     } catch (std::exception& e) {
97056       {
97057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97058       };
97059     } catch (Dali::DaliException e) {
97060       {
97061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97062       };
97063     } catch (...) {
97064       {
97065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97066       };
97067     }
97068   }
97069
97070 }
97071
97072
97073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97074   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97075   Dali::Toolkit::PageTurnView arg2 ;
97076   unsigned int arg3 ;
97077   bool arg4 ;
97078   Dali::Toolkit::PageTurnView *argp2 ;
97079
97080   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97081   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97082   if (!argp2) {
97083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97084     return ;
97085   }
97086   arg2 = *argp2;
97087   arg3 = (unsigned int)jarg3;
97088   arg4 = jarg4 ? true : false;
97089   {
97090     try {
97091       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97092     } catch (std::out_of_range& e) {
97093       {
97094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97095       };
97096     } catch (std::exception& e) {
97097       {
97098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97099       };
97100     } catch (Dali::DaliException e) {
97101       {
97102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97103       };
97104     } catch (...) {
97105       {
97106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97107       };
97108     }
97109   }
97110
97111 }
97112
97113
97114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97115   void * jresult ;
97116   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97117
97118   {
97119     try {
97120       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97121     } catch (std::out_of_range& e) {
97122       {
97123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97124       };
97125     } catch (std::exception& e) {
97126       {
97127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97128       };
97129     } catch (Dali::DaliException e) {
97130       {
97131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97132       };
97133     } catch (...) {
97134       {
97135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97136       };
97137     }
97138   }
97139
97140   jresult = (void *)result;
97141   return jresult;
97142 }
97143
97144
97145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97146   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97147
97148   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97149   {
97150     try {
97151       delete arg1;
97152     } catch (std::out_of_range& e) {
97153       {
97154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97155       };
97156     } catch (std::exception& e) {
97157       {
97158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97159       };
97160     } catch (Dali::DaliException e) {
97161       {
97162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97163       };
97164     } catch (...) {
97165       {
97166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97167       };
97168     }
97169   }
97170
97171 }
97172
97173
97174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97175   unsigned int jresult ;
97176   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97177   bool result;
97178
97179   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97180   {
97181     try {
97182       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97183     } catch (std::out_of_range& e) {
97184       {
97185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97186       };
97187     } catch (std::exception& e) {
97188       {
97189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97190       };
97191     } catch (Dali::DaliException e) {
97192       {
97193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97194       };
97195     } catch (...) {
97196       {
97197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97198       };
97199     }
97200   }
97201
97202   jresult = result;
97203   return jresult;
97204 }
97205
97206
97207 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97208   unsigned long jresult ;
97209   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97210   std::size_t result;
97211
97212   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97213   {
97214     try {
97215       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97216     } catch (std::out_of_range& e) {
97217       {
97218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97219       };
97220     } catch (std::exception& e) {
97221       {
97222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97223       };
97224     } catch (Dali::DaliException e) {
97225       {
97226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97227       };
97228     } catch (...) {
97229       {
97230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97231       };
97232     }
97233   }
97234
97235   jresult = (unsigned long)result;
97236   return jresult;
97237 }
97238
97239
97240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97241   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97242   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97243
97244   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97245   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97246   {
97247     try {
97248       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97249     } catch (std::out_of_range& e) {
97250       {
97251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97252       };
97253     } catch (std::exception& e) {
97254       {
97255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97256       };
97257     } catch (Dali::DaliException e) {
97258       {
97259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97260       };
97261     } catch (...) {
97262       {
97263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97264       };
97265     }
97266   }
97267
97268 }
97269
97270
97271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97272   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97273   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97274
97275   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97276   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97277   {
97278     try {
97279       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97280     } catch (std::out_of_range& e) {
97281       {
97282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97283       };
97284     } catch (std::exception& e) {
97285       {
97286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97287       };
97288     } catch (Dali::DaliException e) {
97289       {
97290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97291       };
97292     } catch (...) {
97293       {
97294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97295       };
97296     }
97297   }
97298
97299 }
97300
97301
97302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97303   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97304   Dali::Toolkit::PageTurnView arg2 ;
97305   Dali::Toolkit::PageTurnView *argp2 ;
97306
97307   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97308   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97309   if (!argp2) {
97310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97311     return ;
97312   }
97313   arg2 = *argp2;
97314   {
97315     try {
97316       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97317     } catch (std::out_of_range& e) {
97318       {
97319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97320       };
97321     } catch (std::exception& e) {
97322       {
97323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97324       };
97325     } catch (Dali::DaliException e) {
97326       {
97327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97328       };
97329     } catch (...) {
97330       {
97331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97332       };
97333     }
97334   }
97335
97336 }
97337
97338
97339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97340   void * jresult ;
97341   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97342
97343   {
97344     try {
97345       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97346     } catch (std::out_of_range& e) {
97347       {
97348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97349       };
97350     } catch (std::exception& e) {
97351       {
97352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97353       };
97354     } catch (Dali::DaliException e) {
97355       {
97356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97357       };
97358     } catch (...) {
97359       {
97360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97361       };
97362     }
97363   }
97364
97365   jresult = (void *)result;
97366   return jresult;
97367 }
97368
97369
97370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97371   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97372
97373   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97374   {
97375     try {
97376       delete arg1;
97377     } catch (std::out_of_range& e) {
97378       {
97379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97380       };
97381     } catch (std::exception& e) {
97382       {
97383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97384       };
97385     } catch (Dali::DaliException e) {
97386       {
97387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97388       };
97389     } catch (...) {
97390       {
97391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97392       };
97393     }
97394   }
97395
97396 }
97397
97398
97399 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97400   unsigned int jresult ;
97401   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97402   bool result;
97403
97404   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97405   {
97406     try {
97407       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);
97408     } catch (std::out_of_range& e) {
97409       {
97410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97411       };
97412     } catch (std::exception& e) {
97413       {
97414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97415       };
97416     } catch (Dali::DaliException e) {
97417       {
97418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97419       };
97420     } catch (...) {
97421       {
97422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97423       };
97424     }
97425   }
97426
97427   jresult = result;
97428   return jresult;
97429 }
97430
97431
97432 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97433   unsigned long jresult ;
97434   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97435   std::size_t result;
97436
97437   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97438   {
97439     try {
97440       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);
97441     } catch (std::out_of_range& e) {
97442       {
97443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97444       };
97445     } catch (std::exception& e) {
97446       {
97447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97448       };
97449     } catch (Dali::DaliException e) {
97450       {
97451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97452       };
97453     } catch (...) {
97454       {
97455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97456       };
97457     }
97458   }
97459
97460   jresult = (unsigned long)result;
97461   return jresult;
97462 }
97463
97464
97465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97466   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97467   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97468
97469   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97470   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97471   {
97472     try {
97473       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97474     } catch (std::out_of_range& e) {
97475       {
97476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97477       };
97478     } catch (std::exception& e) {
97479       {
97480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97481       };
97482     } catch (Dali::DaliException e) {
97483       {
97484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97485       };
97486     } catch (...) {
97487       {
97488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97489       };
97490     }
97491   }
97492
97493 }
97494
97495
97496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97497   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97498   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97499
97500   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97501   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97502   {
97503     try {
97504       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97505     } catch (std::out_of_range& e) {
97506       {
97507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97508       };
97509     } catch (std::exception& e) {
97510       {
97511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97512       };
97513     } catch (Dali::DaliException e) {
97514       {
97515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97516       };
97517     } catch (...) {
97518       {
97519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97520       };
97521     }
97522   }
97523
97524 }
97525
97526
97527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97528   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97529   Dali::Toolkit::ProgressBar arg2 ;
97530   float arg3 ;
97531   float arg4 ;
97532   Dali::Toolkit::ProgressBar *argp2 ;
97533
97534   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97535   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97536   if (!argp2) {
97537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97538     return ;
97539   }
97540   arg2 = *argp2;
97541   arg3 = (float)jarg3;
97542   arg4 = (float)jarg4;
97543   {
97544     try {
97545       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97546     } catch (std::out_of_range& e) {
97547       {
97548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97549       };
97550     } catch (std::exception& e) {
97551       {
97552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97553       };
97554     } catch (Dali::DaliException e) {
97555       {
97556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97557       };
97558     } catch (...) {
97559       {
97560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97561       };
97562     }
97563   }
97564
97565 }
97566
97567
97568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97569   void * jresult ;
97570   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97571
97572   {
97573     try {
97574       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97575     } catch (std::out_of_range& e) {
97576       {
97577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97578       };
97579     } catch (std::exception& e) {
97580       {
97581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97582       };
97583     } catch (Dali::DaliException e) {
97584       {
97585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97586       };
97587     } catch (...) {
97588       {
97589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97590       };
97591     }
97592   }
97593
97594   jresult = (void *)result;
97595   return jresult;
97596 }
97597
97598
97599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97600   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97601
97602   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97603   {
97604     try {
97605       delete arg1;
97606     } catch (std::out_of_range& e) {
97607       {
97608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97609       };
97610     } catch (std::exception& e) {
97611       {
97612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97613       };
97614     } catch (Dali::DaliException e) {
97615       {
97616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97617       };
97618     } catch (...) {
97619       {
97620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97621       };
97622     }
97623   }
97624
97625 }
97626
97627
97628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97629   unsigned int jresult ;
97630   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97631   bool result;
97632
97633   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97634   {
97635     try {
97636       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);
97637     } catch (std::out_of_range& e) {
97638       {
97639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97640       };
97641     } catch (std::exception& e) {
97642       {
97643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97644       };
97645     } catch (Dali::DaliException e) {
97646       {
97647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97648       };
97649     } catch (...) {
97650       {
97651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97652       };
97653     }
97654   }
97655
97656   jresult = result;
97657   return jresult;
97658 }
97659
97660
97661 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97662   unsigned long jresult ;
97663   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97664   std::size_t result;
97665
97666   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97667   {
97668     try {
97669       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);
97670     } catch (std::out_of_range& e) {
97671       {
97672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97673       };
97674     } catch (std::exception& e) {
97675       {
97676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97677       };
97678     } catch (Dali::DaliException e) {
97679       {
97680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97681       };
97682     } catch (...) {
97683       {
97684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97685       };
97686     }
97687   }
97688
97689   jresult = (unsigned long)result;
97690   return jresult;
97691 }
97692
97693
97694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97695   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97696   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97697
97698   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97699   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97700   {
97701     try {
97702       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97703     } catch (std::out_of_range& e) {
97704       {
97705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97706       };
97707     } catch (std::exception& e) {
97708       {
97709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97710       };
97711     } catch (Dali::DaliException e) {
97712       {
97713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97714       };
97715     } catch (...) {
97716       {
97717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97718       };
97719     }
97720   }
97721
97722 }
97723
97724
97725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97726   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97727   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97728
97729   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97730   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97731   {
97732     try {
97733       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97734     } catch (std::out_of_range& e) {
97735       {
97736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97737       };
97738     } catch (std::exception& e) {
97739       {
97740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97741       };
97742     } catch (Dali::DaliException e) {
97743       {
97744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97745       };
97746     } catch (...) {
97747       {
97748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97749       };
97750     }
97751   }
97752
97753 }
97754
97755
97756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97757   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97758   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97759
97760   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97761   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97762   if (!arg2) {
97763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97764     return ;
97765   }
97766   {
97767     try {
97768       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97769     } catch (std::out_of_range& e) {
97770       {
97771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97772       };
97773     } catch (std::exception& e) {
97774       {
97775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97776       };
97777     } catch (Dali::DaliException e) {
97778       {
97779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97780       };
97781     } catch (...) {
97782       {
97783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97784       };
97785     }
97786   }
97787
97788 }
97789
97790
97791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97792   void * jresult ;
97793   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97794
97795   {
97796     try {
97797       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97798     } catch (std::out_of_range& e) {
97799       {
97800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97801       };
97802     } catch (std::exception& e) {
97803       {
97804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97805       };
97806     } catch (Dali::DaliException e) {
97807       {
97808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97809       };
97810     } catch (...) {
97811       {
97812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97813       };
97814     }
97815   }
97816
97817   jresult = (void *)result;
97818   return jresult;
97819 }
97820
97821
97822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97823   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97824
97825   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97826   {
97827     try {
97828       delete arg1;
97829     } catch (std::out_of_range& e) {
97830       {
97831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97832       };
97833     } catch (std::exception& e) {
97834       {
97835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97836       };
97837     } catch (Dali::DaliException e) {
97838       {
97839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97840       };
97841     } catch (...) {
97842       {
97843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97844       };
97845     }
97846   }
97847
97848 }
97849
97850
97851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97852   unsigned int jresult ;
97853   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97854   bool result;
97855
97856   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97857   {
97858     try {
97859       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97860     } catch (std::out_of_range& e) {
97861       {
97862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97863       };
97864     } catch (std::exception& e) {
97865       {
97866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97867       };
97868     } catch (Dali::DaliException e) {
97869       {
97870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97871       };
97872     } catch (...) {
97873       {
97874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97875       };
97876     }
97877   }
97878
97879   jresult = result;
97880   return jresult;
97881 }
97882
97883
97884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97885   unsigned long jresult ;
97886   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97887   std::size_t result;
97888
97889   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97890   {
97891     try {
97892       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97893     } catch (std::out_of_range& e) {
97894       {
97895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97896       };
97897     } catch (std::exception& e) {
97898       {
97899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97900       };
97901     } catch (Dali::DaliException e) {
97902       {
97903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97904       };
97905     } catch (...) {
97906       {
97907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97908       };
97909     }
97910   }
97911
97912   jresult = (unsigned long)result;
97913   return jresult;
97914 }
97915
97916
97917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97918   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97919   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97920
97921   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97922   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97923   {
97924     try {
97925       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97926     } catch (std::out_of_range& e) {
97927       {
97928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97929       };
97930     } catch (std::exception& e) {
97931       {
97932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97933       };
97934     } catch (Dali::DaliException e) {
97935       {
97936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97937       };
97938     } catch (...) {
97939       {
97940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97941       };
97942     }
97943   }
97944
97945 }
97946
97947
97948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97949   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97950   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97951
97952   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97953   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97954   {
97955     try {
97956       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97957     } catch (std::out_of_range& e) {
97958       {
97959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97960       };
97961     } catch (std::exception& e) {
97962       {
97963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97964       };
97965     } catch (Dali::DaliException e) {
97966       {
97967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97968       };
97969     } catch (...) {
97970       {
97971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97972       };
97973     }
97974   }
97975
97976 }
97977
97978
97979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97980   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97981   Dali::Vector2 *arg2 = 0 ;
97982
97983   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97984   arg2 = (Dali::Vector2 *)jarg2;
97985   if (!arg2) {
97986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97987     return ;
97988   }
97989   {
97990     try {
97991       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97992     } catch (std::out_of_range& e) {
97993       {
97994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97995       };
97996     } catch (std::exception& e) {
97997       {
97998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97999       };
98000     } catch (Dali::DaliException e) {
98001       {
98002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98003       };
98004     } catch (...) {
98005       {
98006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98007       };
98008     }
98009   }
98010
98011 }
98012
98013
98014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98015   void * jresult ;
98016   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98017
98018   {
98019     try {
98020       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98021     } catch (std::out_of_range& e) {
98022       {
98023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98024       };
98025     } catch (std::exception& e) {
98026       {
98027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98028       };
98029     } catch (Dali::DaliException e) {
98030       {
98031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98032       };
98033     } catch (...) {
98034       {
98035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98036       };
98037     }
98038   }
98039
98040   jresult = (void *)result;
98041   return jresult;
98042 }
98043
98044
98045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98046   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98047
98048   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98049   {
98050     try {
98051       delete arg1;
98052     } catch (std::out_of_range& e) {
98053       {
98054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98055       };
98056     } catch (std::exception& e) {
98057       {
98058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98059       };
98060     } catch (Dali::DaliException e) {
98061       {
98062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98063       };
98064     } catch (...) {
98065       {
98066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98067       };
98068     }
98069   }
98070
98071 }
98072
98073
98074
98075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98076   unsigned int jresult ;
98077   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98078   bool result;
98079
98080   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98081   {
98082     try {
98083       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);
98084     } catch (std::out_of_range& e) {
98085       {
98086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98087       };
98088     } catch (std::exception& e) {
98089       {
98090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98091       };
98092     } catch (Dali::DaliException e) {
98093       {
98094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98095       };
98096     } catch (...) {
98097       {
98098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98099       };
98100     }
98101   }
98102
98103   jresult = result;
98104   return jresult;
98105 }
98106
98107
98108 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98109   unsigned long jresult ;
98110   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98111   std::size_t result;
98112
98113   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98114   {
98115     try {
98116       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);
98117     } catch (std::out_of_range& e) {
98118       {
98119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98120       };
98121     } catch (std::exception& e) {
98122       {
98123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98124       };
98125     } catch (Dali::DaliException e) {
98126       {
98127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98128       };
98129     } catch (...) {
98130       {
98131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98132       };
98133     }
98134   }
98135
98136   jresult = (unsigned long)result;
98137   return jresult;
98138 }
98139
98140
98141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98142   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98143   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98144
98145   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98146   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98147   {
98148     try {
98149       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98150     } catch (std::out_of_range& e) {
98151       {
98152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98153       };
98154     } catch (std::exception& e) {
98155       {
98156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98157       };
98158     } catch (Dali::DaliException e) {
98159       {
98160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98161       };
98162     } catch (...) {
98163       {
98164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98165       };
98166     }
98167   }
98168
98169 }
98170
98171
98172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98173   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98174   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98175
98176   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98177   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98178   {
98179     try {
98180       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98181     } catch (std::out_of_range& e) {
98182       {
98183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98184       };
98185     } catch (std::exception& e) {
98186       {
98187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98188       };
98189     } catch (Dali::DaliException e) {
98190       {
98191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98192       };
98193     } catch (...) {
98194       {
98195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98196       };
98197     }
98198   }
98199
98200 }
98201
98202
98203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98204   unsigned int jresult ;
98205   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98206   Dali::Toolkit::Control arg2 ;
98207   Dali::KeyEvent *arg3 = 0 ;
98208   Dali::Toolkit::Control *argp2 ;
98209   bool result;
98210
98211   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98212   argp2 = (Dali::Toolkit::Control *)jarg2;
98213   if (!argp2) {
98214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98215     return 0;
98216   }
98217   arg2 = *argp2;
98218   arg3 = (Dali::KeyEvent *)jarg3;
98219   if (!arg3) {
98220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98221     return 0;
98222   }
98223   {
98224     try {
98225       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);
98226     } catch (std::out_of_range& e) {
98227       {
98228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98229       };
98230     } catch (std::exception& e) {
98231       {
98232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98233       };
98234     } catch (Dali::DaliException e) {
98235       {
98236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98237       };
98238     } catch (...) {
98239       {
98240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98241       };
98242     }
98243   }
98244
98245   jresult = result;
98246   return jresult;
98247 }
98248
98249
98250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98251   void * jresult ;
98252   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98253
98254   {
98255     try {
98256       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98257     } catch (std::out_of_range& e) {
98258       {
98259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98260       };
98261     } catch (std::exception& e) {
98262       {
98263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98264       };
98265     } catch (Dali::DaliException e) {
98266       {
98267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98268       };
98269     } catch (...) {
98270       {
98271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98272       };
98273     }
98274   }
98275
98276   jresult = (void *)result;
98277   return jresult;
98278 }
98279
98280
98281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98282   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98283
98284   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98285   {
98286     try {
98287       delete arg1;
98288     } catch (std::out_of_range& e) {
98289       {
98290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98291       };
98292     } catch (std::exception& e) {
98293       {
98294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98295       };
98296     } catch (Dali::DaliException e) {
98297       {
98298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98299       };
98300     } catch (...) {
98301       {
98302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98303       };
98304     }
98305   }
98306
98307 }
98308
98309
98310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98311   unsigned int jresult ;
98312   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98313   bool result;
98314
98315   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98316   {
98317     try {
98318       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98319     } catch (std::out_of_range& e) {
98320       {
98321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98322       };
98323     } catch (std::exception& e) {
98324       {
98325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98326       };
98327     } catch (Dali::DaliException e) {
98328       {
98329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98330       };
98331     } catch (...) {
98332       {
98333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98334       };
98335     }
98336   }
98337
98338   jresult = result;
98339   return jresult;
98340 }
98341
98342
98343 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98344   unsigned long jresult ;
98345   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98346   std::size_t result;
98347
98348   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98349   {
98350     try {
98351       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98352     } catch (std::out_of_range& e) {
98353       {
98354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98355       };
98356     } catch (std::exception& e) {
98357       {
98358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98359       };
98360     } catch (Dali::DaliException e) {
98361       {
98362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98363       };
98364     } catch (...) {
98365       {
98366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98367       };
98368     }
98369   }
98370
98371   jresult = (unsigned long)result;
98372   return jresult;
98373 }
98374
98375
98376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98377   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98378   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98379
98380   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98381   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98382   {
98383     try {
98384       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98385     } catch (std::out_of_range& e) {
98386       {
98387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98388       };
98389     } catch (std::exception& e) {
98390       {
98391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98392       };
98393     } catch (Dali::DaliException e) {
98394       {
98395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98396       };
98397     } catch (...) {
98398       {
98399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98400       };
98401     }
98402   }
98403
98404 }
98405
98406
98407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98408   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98409   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98410
98411   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98412   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98413   {
98414     try {
98415       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98416     } catch (std::out_of_range& e) {
98417       {
98418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98419       };
98420     } catch (std::exception& e) {
98421       {
98422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98423       };
98424     } catch (Dali::DaliException e) {
98425       {
98426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98427       };
98428     } catch (...) {
98429       {
98430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98431       };
98432     }
98433   }
98434
98435 }
98436
98437
98438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98439   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98440   Dali::Toolkit::Control arg2 ;
98441   Dali::Toolkit::Control *argp2 ;
98442
98443   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98444   argp2 = (Dali::Toolkit::Control *)jarg2;
98445   if (!argp2) {
98446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98447     return ;
98448   }
98449   arg2 = *argp2;
98450   {
98451     try {
98452       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98453     } catch (std::out_of_range& e) {
98454       {
98455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98456       };
98457     } catch (std::exception& e) {
98458       {
98459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98460       };
98461     } catch (Dali::DaliException e) {
98462       {
98463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98464       };
98465     } catch (...) {
98466       {
98467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98468       };
98469     }
98470   }
98471
98472 }
98473
98474
98475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98476   void * jresult ;
98477   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98478
98479   {
98480     try {
98481       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98482     } catch (std::out_of_range& e) {
98483       {
98484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98485       };
98486     } catch (std::exception& e) {
98487       {
98488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98489       };
98490     } catch (Dali::DaliException e) {
98491       {
98492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98493       };
98494     } catch (...) {
98495       {
98496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98497       };
98498     }
98499   }
98500
98501   jresult = (void *)result;
98502   return jresult;
98503 }
98504
98505
98506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98507   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98508
98509   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98510   {
98511     try {
98512       delete arg1;
98513     } catch (std::out_of_range& e) {
98514       {
98515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98516       };
98517     } catch (std::exception& e) {
98518       {
98519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98520       };
98521     } catch (Dali::DaliException e) {
98522       {
98523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98524       };
98525     } catch (...) {
98526       {
98527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98528       };
98529     }
98530   }
98531
98532 }
98533
98534
98535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98536   unsigned int jresult ;
98537   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98538   bool result;
98539
98540   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98541   {
98542     try {
98543       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98544     } catch (std::out_of_range& e) {
98545       {
98546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98547       };
98548     } catch (std::exception& e) {
98549       {
98550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98551       };
98552     } catch (Dali::DaliException e) {
98553       {
98554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98555       };
98556     } catch (...) {
98557       {
98558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98559       };
98560     }
98561   }
98562
98563   jresult = result;
98564   return jresult;
98565 }
98566
98567
98568 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98569   unsigned long jresult ;
98570   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98571   std::size_t result;
98572
98573   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98574   {
98575     try {
98576       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98577     } catch (std::out_of_range& e) {
98578       {
98579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98580       };
98581     } catch (std::exception& e) {
98582       {
98583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98584       };
98585     } catch (Dali::DaliException e) {
98586       {
98587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98588       };
98589     } catch (...) {
98590       {
98591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98592       };
98593     }
98594   }
98595
98596   jresult = (unsigned long)result;
98597   return jresult;
98598 }
98599
98600
98601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98602   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98603   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98604
98605   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98606   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98607   {
98608     try {
98609       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98610     } catch (std::out_of_range& e) {
98611       {
98612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98613       };
98614     } catch (std::exception& e) {
98615       {
98616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98617       };
98618     } catch (Dali::DaliException e) {
98619       {
98620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98621       };
98622     } catch (...) {
98623       {
98624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98625       };
98626     }
98627   }
98628
98629 }
98630
98631
98632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98633   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98634   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98635
98636   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98637   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98638   {
98639     try {
98640       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98641     } catch (std::out_of_range& e) {
98642       {
98643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98644       };
98645     } catch (std::exception& e) {
98646       {
98647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98648       };
98649     } catch (Dali::DaliException e) {
98650       {
98651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98652       };
98653     } catch (...) {
98654       {
98655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98656       };
98657     }
98658   }
98659
98660 }
98661
98662
98663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98664   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98665   Dali::Toolkit::VideoView *arg2 = 0 ;
98666
98667   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98668   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98669   if (!arg2) {
98670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98671     return ;
98672   }
98673   {
98674     try {
98675       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98676     } catch (std::out_of_range& e) {
98677       {
98678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98679       };
98680     } catch (std::exception& e) {
98681       {
98682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98683       };
98684     } catch (Dali::DaliException e) {
98685       {
98686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98687       };
98688     } catch (...) {
98689       {
98690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98691       };
98692     }
98693   }
98694
98695 }
98696
98697
98698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98699   void * jresult ;
98700   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98701
98702   {
98703     try {
98704       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98705     } catch (std::out_of_range& e) {
98706       {
98707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98708       };
98709     } catch (std::exception& e) {
98710       {
98711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98712       };
98713     } catch (Dali::DaliException e) {
98714       {
98715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98716       };
98717     } catch (...) {
98718       {
98719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98720       };
98721     }
98722   }
98723
98724   jresult = (void *)result;
98725   return jresult;
98726 }
98727
98728
98729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98730   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98731
98732   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98733   {
98734     try {
98735       delete arg1;
98736     } catch (std::out_of_range& e) {
98737       {
98738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98739       };
98740     } catch (std::exception& e) {
98741       {
98742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98743       };
98744     } catch (Dali::DaliException e) {
98745       {
98746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98747       };
98748     } catch (...) {
98749       {
98750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98751       };
98752     }
98753   }
98754
98755 }
98756
98757
98758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98759   unsigned int jresult ;
98760   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98761   bool result;
98762
98763   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98764   {
98765     try {
98766       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98767     } catch (std::out_of_range& e) {
98768       {
98769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98770       };
98771     } catch (std::exception& e) {
98772       {
98773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98774       };
98775     } catch (Dali::DaliException e) {
98776       {
98777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98778       };
98779     } catch (...) {
98780       {
98781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98782       };
98783     }
98784   }
98785
98786   jresult = result;
98787   return jresult;
98788 }
98789
98790
98791 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98792   unsigned long jresult ;
98793   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98794   std::size_t result;
98795
98796   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98797   {
98798     try {
98799       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98800     } catch (std::out_of_range& e) {
98801       {
98802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98803       };
98804     } catch (std::exception& e) {
98805       {
98806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98807       };
98808     } catch (Dali::DaliException e) {
98809       {
98810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98811       };
98812     } catch (...) {
98813       {
98814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98815       };
98816     }
98817   }
98818
98819   jresult = (unsigned long)result;
98820   return jresult;
98821 }
98822
98823
98824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98825   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98826   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98827
98828   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98829   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98830   {
98831     try {
98832       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98833     } catch (std::out_of_range& e) {
98834       {
98835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98836       };
98837     } catch (std::exception& e) {
98838       {
98839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98840       };
98841     } catch (Dali::DaliException e) {
98842       {
98843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98844       };
98845     } catch (...) {
98846       {
98847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98848       };
98849     }
98850   }
98851
98852 }
98853
98854
98855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98856   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98857   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98858
98859   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98860   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98861   {
98862     try {
98863       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98864     } catch (std::out_of_range& e) {
98865       {
98866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98867       };
98868     } catch (std::exception& e) {
98869       {
98870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98871       };
98872     } catch (Dali::DaliException e) {
98873       {
98874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98875       };
98876     } catch (...) {
98877       {
98878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98879       };
98880     }
98881   }
98882
98883 }
98884
98885
98886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98887   unsigned int jresult ;
98888   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98889   Dali::Toolkit::Slider arg2 ;
98890   float arg3 ;
98891   Dali::Toolkit::Slider *argp2 ;
98892   bool result;
98893
98894   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98895   argp2 = (Dali::Toolkit::Slider *)jarg2;
98896   if (!argp2) {
98897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98898     return 0;
98899   }
98900   arg2 = *argp2;
98901   arg3 = (float)jarg3;
98902   {
98903     try {
98904       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98905     } catch (std::out_of_range& e) {
98906       {
98907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98908       };
98909     } catch (std::exception& e) {
98910       {
98911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98912       };
98913     } catch (Dali::DaliException e) {
98914       {
98915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98916       };
98917     } catch (...) {
98918       {
98919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98920       };
98921     }
98922   }
98923
98924   jresult = result;
98925   return jresult;
98926 }
98927
98928
98929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98930   void * jresult ;
98931   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98932
98933   {
98934     try {
98935       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98936     } catch (std::out_of_range& e) {
98937       {
98938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98939       };
98940     } catch (std::exception& e) {
98941       {
98942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98943       };
98944     } catch (Dali::DaliException e) {
98945       {
98946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98947       };
98948     } catch (...) {
98949       {
98950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98951       };
98952     }
98953   }
98954
98955   jresult = (void *)result;
98956   return jresult;
98957 }
98958
98959
98960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98961   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98962
98963   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98964   {
98965     try {
98966       delete arg1;
98967     } catch (std::out_of_range& e) {
98968       {
98969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98970       };
98971     } catch (std::exception& e) {
98972       {
98973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98974       };
98975     } catch (Dali::DaliException e) {
98976       {
98977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98978       };
98979     } catch (...) {
98980       {
98981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98982       };
98983     }
98984   }
98985
98986 }
98987
98988
98989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98990   unsigned int jresult ;
98991   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98992   bool result;
98993
98994   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98995   {
98996     try {
98997       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98998     } catch (std::out_of_range& e) {
98999       {
99000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99001       };
99002     } catch (std::exception& e) {
99003       {
99004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99005       };
99006     } catch (Dali::DaliException e) {
99007       {
99008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99009       };
99010     } catch (...) {
99011       {
99012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99013       };
99014     }
99015   }
99016
99017   jresult = result;
99018   return jresult;
99019 }
99020
99021
99022 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99023   unsigned long jresult ;
99024   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99025   std::size_t result;
99026
99027   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99028   {
99029     try {
99030       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99031     } catch (std::out_of_range& e) {
99032       {
99033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99034       };
99035     } catch (std::exception& e) {
99036       {
99037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99038       };
99039     } catch (Dali::DaliException e) {
99040       {
99041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99042       };
99043     } catch (...) {
99044       {
99045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99046       };
99047     }
99048   }
99049
99050   jresult = (unsigned long)result;
99051   return jresult;
99052 }
99053
99054
99055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99056   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99057   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99058
99059   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99060   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99061   {
99062     try {
99063       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99064     } catch (std::out_of_range& e) {
99065       {
99066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99067       };
99068     } catch (std::exception& e) {
99069       {
99070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99071       };
99072     } catch (Dali::DaliException e) {
99073       {
99074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99075       };
99076     } catch (...) {
99077       {
99078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99079       };
99080     }
99081   }
99082
99083 }
99084
99085
99086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99087   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99088   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99089
99090   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99091   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99092   {
99093     try {
99094       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99095     } catch (std::out_of_range& e) {
99096       {
99097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99098       };
99099     } catch (std::exception& e) {
99100       {
99101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99102       };
99103     } catch (Dali::DaliException e) {
99104       {
99105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99106       };
99107     } catch (...) {
99108       {
99109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99110       };
99111     }
99112   }
99113
99114 }
99115
99116
99117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99118   unsigned int jresult ;
99119   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99120   Dali::Toolkit::Slider arg2 ;
99121   int arg3 ;
99122   Dali::Toolkit::Slider *argp2 ;
99123   bool result;
99124
99125   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99126   argp2 = (Dali::Toolkit::Slider *)jarg2;
99127   if (!argp2) {
99128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99129     return 0;
99130   }
99131   arg2 = *argp2;
99132   arg3 = (int)jarg3;
99133   {
99134     try {
99135       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99136     } catch (std::out_of_range& e) {
99137       {
99138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99139       };
99140     } catch (std::exception& e) {
99141       {
99142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99143       };
99144     } catch (Dali::DaliException e) {
99145       {
99146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99147       };
99148     } catch (...) {
99149       {
99150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99151       };
99152     }
99153   }
99154
99155   jresult = result;
99156   return jresult;
99157 }
99158
99159
99160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99161   void * jresult ;
99162   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99163
99164   {
99165     try {
99166       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99167     } catch (std::out_of_range& e) {
99168       {
99169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99170       };
99171     } catch (std::exception& e) {
99172       {
99173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99174       };
99175     } catch (Dali::DaliException e) {
99176       {
99177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99178       };
99179     } catch (...) {
99180       {
99181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99182       };
99183     }
99184   }
99185
99186   jresult = (void *)result;
99187   return jresult;
99188 }
99189
99190
99191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99192   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99193
99194   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99195   {
99196     try {
99197       delete arg1;
99198     } catch (std::out_of_range& e) {
99199       {
99200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99201       };
99202     } catch (std::exception& e) {
99203       {
99204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99205       };
99206     } catch (Dali::DaliException e) {
99207       {
99208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99209       };
99210     } catch (...) {
99211       {
99212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99213       };
99214     }
99215   }
99216
99217 }
99218
99219
99220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99221   void * jresult ;
99222   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99223
99224   {
99225     try {
99226       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99227     } catch (std::out_of_range& e) {
99228       {
99229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99230       };
99231     } catch (std::exception& e) {
99232       {
99233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99234       };
99235     } catch (Dali::DaliException e) {
99236       {
99237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99238       };
99239     } catch (...) {
99240       {
99241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99242       };
99243     }
99244   }
99245
99246   jresult = (void *)result;
99247   return jresult;
99248 }
99249
99250
99251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99252   void * jresult ;
99253   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99254   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99255
99256   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99257   {
99258     try {
99259       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99260     } catch (std::out_of_range& e) {
99261       {
99262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99263       };
99264     } catch (std::exception& e) {
99265       {
99266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99267       };
99268     } catch (Dali::DaliException e) {
99269       {
99270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99271       };
99272     } catch (...) {
99273       {
99274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99275       };
99276     }
99277   }
99278
99279   jresult = (void *)result;
99280   return jresult;
99281 }
99282
99283
99284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99285   void * jresult ;
99286   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99287   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99288
99289   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99290   if (!arg1) {
99291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99292     return 0;
99293   }
99294   {
99295     try {
99296       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99297     } catch (std::out_of_range& e) {
99298       {
99299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99300       };
99301     } catch (std::exception& e) {
99302       {
99303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99304       };
99305     } catch (Dali::DaliException e) {
99306       {
99307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99308       };
99309     } catch (...) {
99310       {
99311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99312       };
99313     }
99314   }
99315
99316   jresult = (void *)result;
99317   return jresult;
99318 }
99319
99320
99321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99322   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99323
99324   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99325   {
99326     try {
99327       delete arg1;
99328     } catch (std::out_of_range& e) {
99329       {
99330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99331       };
99332     } catch (std::exception& e) {
99333       {
99334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99335       };
99336     } catch (Dali::DaliException e) {
99337       {
99338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99339       };
99340     } catch (...) {
99341       {
99342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99343       };
99344     }
99345   }
99346
99347 }
99348
99349
99350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99351   void * jresult ;
99352   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99353   Dali::Toolkit::Ruler *result = 0 ;
99354
99355   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99356   {
99357     try {
99358       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99359     } catch (std::out_of_range& e) {
99360       {
99361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99362       };
99363     } catch (std::exception& e) {
99364       {
99365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99366       };
99367     } catch (Dali::DaliException e) {
99368       {
99369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99370       };
99371     } catch (...) {
99372       {
99373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99374       };
99375     }
99376   }
99377
99378   jresult = (void *)result;
99379   return jresult;
99380 }
99381
99382
99383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99384   void * jresult ;
99385   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99386   Dali::Toolkit::Ruler *result = 0 ;
99387
99388   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99389   {
99390     try {
99391       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99392     } catch (std::out_of_range& e) {
99393       {
99394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99395       };
99396     } catch (std::exception& e) {
99397       {
99398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99399       };
99400     } catch (Dali::DaliException e) {
99401       {
99402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99403       };
99404     } catch (...) {
99405       {
99406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99407       };
99408     }
99409   }
99410
99411   jresult = (void *)result;
99412   return jresult;
99413 }
99414
99415
99416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99417   void * jresult ;
99418   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99419   Dali::Toolkit::Ruler *result = 0 ;
99420
99421   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99422   {
99423     try {
99424       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99425     } catch (std::out_of_range& e) {
99426       {
99427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99428       };
99429     } catch (std::exception& e) {
99430       {
99431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99432       };
99433     } catch (Dali::DaliException e) {
99434       {
99435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99436       };
99437     } catch (...) {
99438       {
99439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99440       };
99441     }
99442   }
99443
99444   jresult = (void *)result;
99445   return jresult;
99446 }
99447
99448
99449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99450   void * jresult ;
99451   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99452   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99453   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99454
99455   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99456   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99457   if (!arg2) {
99458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99459     return 0;
99460   }
99461   {
99462     try {
99463       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99464     } catch (std::out_of_range& e) {
99465       {
99466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99467       };
99468     } catch (std::exception& e) {
99469       {
99470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99471       };
99472     } catch (Dali::DaliException e) {
99473       {
99474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99475       };
99476     } catch (...) {
99477       {
99478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99479       };
99480     }
99481   }
99482
99483   jresult = (void *)result;
99484   return jresult;
99485 }
99486
99487
99488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99489   void * jresult ;
99490   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99491   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99492   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99493
99494   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99495   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99496   {
99497     try {
99498       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99499     } catch (std::out_of_range& e) {
99500       {
99501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99502       };
99503     } catch (std::exception& e) {
99504       {
99505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99506       };
99507     } catch (Dali::DaliException e) {
99508       {
99509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99510       };
99511     } catch (...) {
99512       {
99513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99514       };
99515     }
99516   }
99517
99518   jresult = (void *)result;
99519   return jresult;
99520 }
99521
99522
99523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99524   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99525
99526   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99527   {
99528     try {
99529       (arg1)->Reset();
99530     } catch (std::out_of_range& e) {
99531       {
99532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99533       };
99534     } catch (std::exception& e) {
99535       {
99536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99537       };
99538     } catch (Dali::DaliException e) {
99539       {
99540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99541       };
99542     } catch (...) {
99543       {
99544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99545       };
99546     }
99547   }
99548
99549 }
99550
99551
99552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99553   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99554   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99555
99556   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99557   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99558   {
99559     try {
99560       (arg1)->Reset(arg2);
99561     } catch (std::out_of_range& e) {
99562       {
99563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99564       };
99565     } catch (std::exception& e) {
99566       {
99567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99568       };
99569     } catch (Dali::DaliException e) {
99570       {
99571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99572       };
99573     } catch (...) {
99574       {
99575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99576       };
99577     }
99578   }
99579
99580 }
99581
99582
99583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99584   void * jresult ;
99585   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99586   Dali::Toolkit::Ruler *result = 0 ;
99587
99588   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99589   {
99590     try {
99591       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99592     } catch (std::out_of_range& e) {
99593       {
99594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99595       };
99596     } catch (std::exception& e) {
99597       {
99598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99599       };
99600     } catch (Dali::DaliException e) {
99601       {
99602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99603       };
99604     } catch (...) {
99605       {
99606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99607       };
99608     }
99609   }
99610
99611   jresult = (void *)result;
99612   return jresult;
99613 }
99614
99615
99616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99617   float jresult ;
99618   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99619   float arg2 ;
99620   float arg3 ;
99621   float result;
99622
99623   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99624   arg2 = (float)jarg2;
99625   arg3 = (float)jarg3;
99626   {
99627     try {
99628       result = (float)(*arg1)->Snap(arg2,arg3);
99629     } catch (std::out_of_range& e) {
99630       {
99631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99632       };
99633     } catch (std::exception& e) {
99634       {
99635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99636       };
99637     } catch (Dali::DaliException e) {
99638       {
99639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99640       };
99641     } catch (...) {
99642       {
99643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99644       };
99645     }
99646   }
99647
99648   jresult = result;
99649   return jresult;
99650 }
99651
99652
99653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99654   float jresult ;
99655   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99656   float arg2 ;
99657   float result;
99658
99659   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99660   arg2 = (float)jarg2;
99661   {
99662     try {
99663       result = (float)(*arg1)->Snap(arg2);
99664     } catch (std::out_of_range& e) {
99665       {
99666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99667       };
99668     } catch (std::exception& e) {
99669       {
99670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99671       };
99672     } catch (Dali::DaliException e) {
99673       {
99674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99675       };
99676     } catch (...) {
99677       {
99678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99679       };
99680     }
99681   }
99682
99683   jresult = result;
99684   return jresult;
99685 }
99686
99687
99688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99689   float jresult ;
99690   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99691   unsigned int arg2 ;
99692   unsigned int *arg3 = 0 ;
99693   bool arg4 ;
99694   float result;
99695
99696   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99697   arg2 = (unsigned int)jarg2;
99698   arg3 = (unsigned int *)jarg3;
99699   arg4 = jarg4 ? true : false;
99700   {
99701     try {
99702       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99703     } catch (std::out_of_range& e) {
99704       {
99705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99706       };
99707     } catch (std::exception& e) {
99708       {
99709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99710       };
99711     } catch (Dali::DaliException e) {
99712       {
99713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99714       };
99715     } catch (...) {
99716       {
99717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99718       };
99719     }
99720   }
99721
99722   jresult = result;
99723   return jresult;
99724 }
99725
99726
99727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99728   unsigned int jresult ;
99729   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99730   float arg2 ;
99731   bool arg3 ;
99732   unsigned int result;
99733
99734   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99735   arg2 = (float)jarg2;
99736   arg3 = jarg3 ? true : false;
99737   {
99738     try {
99739       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99740     } catch (std::out_of_range& e) {
99741       {
99742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99743       };
99744     } catch (std::exception& e) {
99745       {
99746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99747       };
99748     } catch (Dali::DaliException e) {
99749       {
99750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99751       };
99752     } catch (...) {
99753       {
99754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99755       };
99756     }
99757   }
99758
99759   jresult = result;
99760   return jresult;
99761 }
99762
99763
99764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99765   unsigned int jresult ;
99766   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99767   unsigned int result;
99768
99769   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99770   {
99771     try {
99772       result = (unsigned int)(*arg1)->GetTotalPages();
99773     } catch (std::out_of_range& e) {
99774       {
99775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99776       };
99777     } catch (std::exception& e) {
99778       {
99779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99780       };
99781     } catch (Dali::DaliException e) {
99782       {
99783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99784       };
99785     } catch (...) {
99786       {
99787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99788       };
99789     }
99790   }
99791
99792   jresult = result;
99793   return jresult;
99794 }
99795
99796
99797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99798   int jresult ;
99799   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99800   Dali::Toolkit::Ruler::RulerType result;
99801
99802   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99803   {
99804     try {
99805       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99806     } catch (std::out_of_range& e) {
99807       {
99808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99809       };
99810     } catch (std::exception& e) {
99811       {
99812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99813       };
99814     } catch (Dali::DaliException e) {
99815       {
99816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99817       };
99818     } catch (...) {
99819       {
99820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99821       };
99822     }
99823   }
99824
99825   jresult = (int)result;
99826   return jresult;
99827 }
99828
99829
99830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99831   unsigned int jresult ;
99832   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99833   bool result;
99834
99835   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99836   {
99837     try {
99838       result = (bool)(*arg1)->IsEnabled();
99839     } catch (std::out_of_range& e) {
99840       {
99841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99842       };
99843     } catch (std::exception& e) {
99844       {
99845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99846       };
99847     } catch (Dali::DaliException e) {
99848       {
99849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99850       };
99851     } catch (...) {
99852       {
99853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99854       };
99855     }
99856   }
99857
99858   jresult = result;
99859   return jresult;
99860 }
99861
99862
99863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99864   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99865
99866   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99867   {
99868     try {
99869       (*arg1)->Enable();
99870     } catch (std::out_of_range& e) {
99871       {
99872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99873       };
99874     } catch (std::exception& e) {
99875       {
99876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99877       };
99878     } catch (Dali::DaliException e) {
99879       {
99880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99881       };
99882     } catch (...) {
99883       {
99884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99885       };
99886     }
99887   }
99888
99889 }
99890
99891
99892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99893   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99894
99895   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99896   {
99897     try {
99898       (*arg1)->Disable();
99899     } catch (std::out_of_range& e) {
99900       {
99901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99902       };
99903     } catch (std::exception& e) {
99904       {
99905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99906       };
99907     } catch (Dali::DaliException e) {
99908       {
99909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99910       };
99911     } catch (...) {
99912       {
99913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99914       };
99915     }
99916   }
99917
99918 }
99919
99920
99921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99922   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99923   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99924   Dali::Toolkit::RulerDomain *argp2 ;
99925
99926   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99927   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99928   if (!argp2) {
99929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99930     return ;
99931   }
99932   arg2 = *argp2;
99933   {
99934     try {
99935       (*arg1)->SetDomain(arg2);
99936     } catch (std::out_of_range& e) {
99937       {
99938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99939       };
99940     } catch (std::exception& e) {
99941       {
99942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99943       };
99944     } catch (Dali::DaliException e) {
99945       {
99946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99947       };
99948     } catch (...) {
99949       {
99950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99951       };
99952     }
99953   }
99954
99955 }
99956
99957
99958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99959   void * jresult ;
99960   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99961   Dali::Toolkit::RulerDomain *result = 0 ;
99962
99963   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99964   {
99965     try {
99966       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99967     } catch (std::out_of_range& e) {
99968       {
99969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99970       };
99971     } catch (std::exception& e) {
99972       {
99973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99974       };
99975     } catch (Dali::DaliException e) {
99976       {
99977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99978       };
99979     } catch (...) {
99980       {
99981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99982       };
99983     }
99984   }
99985
99986   jresult = (void *)result;
99987   return jresult;
99988 }
99989
99990
99991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99992   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99993
99994   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99995   {
99996     try {
99997       (*arg1)->DisableDomain();
99998     } catch (std::out_of_range& e) {
99999       {
100000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100001       };
100002     } catch (std::exception& e) {
100003       {
100004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100005       };
100006     } catch (Dali::DaliException e) {
100007       {
100008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100009       };
100010     } catch (...) {
100011       {
100012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100013       };
100014     }
100015   }
100016
100017 }
100018
100019
100020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100021   float jresult ;
100022   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100023   float arg2 ;
100024   float arg3 ;
100025   float arg4 ;
100026   float result;
100027
100028   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100029   arg2 = (float)jarg2;
100030   arg3 = (float)jarg3;
100031   arg4 = (float)jarg4;
100032   {
100033     try {
100034       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100035     } catch (std::out_of_range& e) {
100036       {
100037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100038       };
100039     } catch (std::exception& e) {
100040       {
100041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100042       };
100043     } catch (Dali::DaliException e) {
100044       {
100045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100046       };
100047     } catch (...) {
100048       {
100049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100050       };
100051     }
100052   }
100053
100054   jresult = result;
100055   return jresult;
100056 }
100057
100058
100059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100060   float jresult ;
100061   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100062   float arg2 ;
100063   float arg3 ;
100064   float result;
100065
100066   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100067   arg2 = (float)jarg2;
100068   arg3 = (float)jarg3;
100069   {
100070     try {
100071       result = (float)(*arg1)->Clamp(arg2,arg3);
100072     } catch (std::out_of_range& e) {
100073       {
100074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100075       };
100076     } catch (std::exception& e) {
100077       {
100078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100079       };
100080     } catch (Dali::DaliException e) {
100081       {
100082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100083       };
100084     } catch (...) {
100085       {
100086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100087       };
100088     }
100089   }
100090
100091   jresult = result;
100092   return jresult;
100093 }
100094
100095
100096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100097   float jresult ;
100098   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100099   float arg2 ;
100100   float result;
100101
100102   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100103   arg2 = (float)jarg2;
100104   {
100105     try {
100106       result = (float)(*arg1)->Clamp(arg2);
100107     } catch (std::out_of_range& e) {
100108       {
100109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100110       };
100111     } catch (std::exception& e) {
100112       {
100113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100114       };
100115     } catch (Dali::DaliException e) {
100116       {
100117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100118       };
100119     } catch (...) {
100120       {
100121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100122       };
100123     }
100124   }
100125
100126   jresult = result;
100127   return jresult;
100128 }
100129
100130
100131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100132   float jresult ;
100133   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100134   float arg2 ;
100135   float arg3 ;
100136   float arg4 ;
100137   Dali::Toolkit::ClampState *arg5 = 0 ;
100138   float result;
100139
100140   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100141   arg2 = (float)jarg2;
100142   arg3 = (float)jarg3;
100143   arg4 = (float)jarg4;
100144   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100145   if (!arg5) {
100146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100147     return 0;
100148   }
100149   {
100150     try {
100151       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100152     } catch (std::out_of_range& e) {
100153       {
100154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100155       };
100156     } catch (std::exception& e) {
100157       {
100158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100159       };
100160     } catch (Dali::DaliException e) {
100161       {
100162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100163       };
100164     } catch (...) {
100165       {
100166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100167       };
100168     }
100169   }
100170
100171   jresult = result;
100172   return jresult;
100173 }
100174
100175
100176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100177   float jresult ;
100178   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100179   float arg2 ;
100180   float arg3 ;
100181   float arg4 ;
100182   float arg5 ;
100183   float result;
100184
100185   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100186   arg2 = (float)jarg2;
100187   arg3 = (float)jarg3;
100188   arg4 = (float)jarg4;
100189   arg5 = (float)jarg5;
100190   {
100191     try {
100192       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100193     } catch (std::out_of_range& e) {
100194       {
100195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100196       };
100197     } catch (std::exception& e) {
100198       {
100199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100200       };
100201     } catch (Dali::DaliException e) {
100202       {
100203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100204       };
100205     } catch (...) {
100206       {
100207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100208       };
100209     }
100210   }
100211
100212   jresult = result;
100213   return jresult;
100214 }
100215
100216
100217 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100218   float jresult ;
100219   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100220   float arg2 ;
100221   float arg3 ;
100222   float arg4 ;
100223   float result;
100224
100225   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100226   arg2 = (float)jarg2;
100227   arg3 = (float)jarg3;
100228   arg4 = (float)jarg4;
100229   {
100230     try {
100231       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100232     } catch (std::out_of_range& e) {
100233       {
100234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100235       };
100236     } catch (std::exception& e) {
100237       {
100238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100239       };
100240     } catch (Dali::DaliException e) {
100241       {
100242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100243       };
100244     } catch (...) {
100245       {
100246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100247       };
100248     }
100249   }
100250
100251   jresult = result;
100252   return jresult;
100253 }
100254
100255
100256 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100257   float jresult ;
100258   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100259   float arg2 ;
100260   float arg3 ;
100261   float result;
100262
100263   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100264   arg2 = (float)jarg2;
100265   arg3 = (float)jarg3;
100266   {
100267     try {
100268       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100269     } catch (std::out_of_range& e) {
100270       {
100271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100272       };
100273     } catch (std::exception& e) {
100274       {
100275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100276       };
100277     } catch (Dali::DaliException e) {
100278       {
100279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100280       };
100281     } catch (...) {
100282       {
100283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100284       };
100285     }
100286   }
100287
100288   jresult = result;
100289   return jresult;
100290 }
100291
100292
100293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100294   float jresult ;
100295   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100296   float arg2 ;
100297   float result;
100298
100299   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100300   arg2 = (float)jarg2;
100301   {
100302     try {
100303       result = (float)(*arg1)->SnapAndClamp(arg2);
100304     } catch (std::out_of_range& e) {
100305       {
100306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100307       };
100308     } catch (std::exception& e) {
100309       {
100310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100311       };
100312     } catch (Dali::DaliException e) {
100313       {
100314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100315       };
100316     } catch (...) {
100317       {
100318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100319       };
100320     }
100321   }
100322
100323   jresult = result;
100324   return jresult;
100325 }
100326
100327
100328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100329   float jresult ;
100330   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100331   float arg2 ;
100332   float arg3 ;
100333   float arg4 ;
100334   float arg5 ;
100335   Dali::Toolkit::ClampState *arg6 = 0 ;
100336   float result;
100337
100338   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100339   arg2 = (float)jarg2;
100340   arg3 = (float)jarg3;
100341   arg4 = (float)jarg4;
100342   arg5 = (float)jarg5;
100343   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100344   if (!arg6) {
100345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100346     return 0;
100347   }
100348   {
100349     try {
100350       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100351     } catch (std::out_of_range& e) {
100352       {
100353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100354       };
100355     } catch (std::exception& e) {
100356       {
100357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100358       };
100359     } catch (Dali::DaliException e) {
100360       {
100361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100362       };
100363     } catch (...) {
100364       {
100365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100366       };
100367     }
100368   }
100369
100370   jresult = result;
100371   return jresult;
100372 }
100373
100374
100375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100376   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100377
100378   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100379   {
100380     try {
100381       (*arg1)->Reference();
100382     } catch (std::out_of_range& e) {
100383       {
100384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100385       };
100386     } catch (std::exception& e) {
100387       {
100388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100389       };
100390     } catch (Dali::DaliException e) {
100391       {
100392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100393       };
100394     } catch (...) {
100395       {
100396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100397       };
100398     }
100399   }
100400
100401 }
100402
100403
100404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100405   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100406
100407   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100408   {
100409     try {
100410       (*arg1)->Unreference();
100411     } catch (std::out_of_range& e) {
100412       {
100413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100414       };
100415     } catch (std::exception& e) {
100416       {
100417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100418       };
100419     } catch (Dali::DaliException e) {
100420       {
100421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100422       };
100423     } catch (...) {
100424       {
100425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100426       };
100427     }
100428   }
100429
100430 }
100431
100432
100433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100434   int jresult ;
100435   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100436   int result;
100437
100438   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100439   {
100440     try {
100441       result = (int)(*arg1)->ReferenceCount();
100442     } catch (std::out_of_range& e) {
100443       {
100444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100445       };
100446     } catch (std::exception& e) {
100447       {
100448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100449       };
100450     } catch (Dali::DaliException e) {
100451       {
100452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100453       };
100454     } catch (...) {
100455       {
100456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100457       };
100458     }
100459   }
100460
100461   jresult = result;
100462   return jresult;
100463 }
100464
100465
100466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100467   unsigned int jresult ;
100468   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100469   bool result;
100470
100471   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100472   {
100473     try {
100474       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100475     } catch (std::out_of_range& e) {
100476       {
100477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100478       };
100479     } catch (std::exception& e) {
100480       {
100481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100482       };
100483     } catch (Dali::DaliException e) {
100484       {
100485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100486       };
100487     } catch (...) {
100488       {
100489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100490       };
100491     }
100492   }
100493
100494   jresult = result;
100495   return jresult;
100496 }
100497
100498
100499 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100500   unsigned long jresult ;
100501   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100502   std::size_t result;
100503
100504   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100505   {
100506     try {
100507       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100508     } catch (std::out_of_range& e) {
100509       {
100510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100511       };
100512     } catch (std::exception& e) {
100513       {
100514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100515       };
100516     } catch (Dali::DaliException e) {
100517       {
100518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100519       };
100520     } catch (...) {
100521       {
100522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100523       };
100524     }
100525   }
100526
100527   jresult = (unsigned long)result;
100528   return jresult;
100529 }
100530
100531
100532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100533   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100534   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100535
100536   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100537   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100538   {
100539     try {
100540       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100541     } catch (std::out_of_range& e) {
100542       {
100543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100544       };
100545     } catch (std::exception& e) {
100546       {
100547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100548       };
100549     } catch (Dali::DaliException e) {
100550       {
100551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100552       };
100553     } catch (...) {
100554       {
100555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100556       };
100557     }
100558   }
100559
100560 }
100561
100562
100563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100564   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100565   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100566
100567   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100568   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100569   {
100570     try {
100571       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100572     } catch (std::out_of_range& e) {
100573       {
100574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100575       };
100576     } catch (std::exception& e) {
100577       {
100578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100579       };
100580     } catch (Dali::DaliException e) {
100581       {
100582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100583       };
100584     } catch (...) {
100585       {
100586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100587       };
100588     }
100589   }
100590
100591 }
100592
100593
100594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100595   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100596   Dali::Toolkit::Control arg2 ;
100597   Dali::Toolkit::Control *argp2 ;
100598
100599   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100600   argp2 = (Dali::Toolkit::Control *)jarg2;
100601   if (!argp2) {
100602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100603     return ;
100604   }
100605   arg2 = *argp2;
100606   {
100607     try {
100608       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100609     } catch (std::out_of_range& e) {
100610       {
100611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100612       };
100613     } catch (std::exception& e) {
100614       {
100615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100616       };
100617     } catch (Dali::DaliException e) {
100618       {
100619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100620       };
100621     } catch (...) {
100622       {
100623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100624       };
100625     }
100626   }
100627
100628 }
100629
100630
100631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100632   void * jresult ;
100633   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100634
100635   {
100636     try {
100637       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100638     } catch (std::out_of_range& e) {
100639       {
100640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100641       };
100642     } catch (std::exception& e) {
100643       {
100644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100645       };
100646     } catch (Dali::DaliException e) {
100647       {
100648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100649       };
100650     } catch (...) {
100651       {
100652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100653       };
100654     }
100655   }
100656
100657   jresult = (void *)result;
100658   return jresult;
100659 }
100660
100661
100662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100663   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100664
100665   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100666   {
100667     try {
100668       delete arg1;
100669     } catch (std::out_of_range& e) {
100670       {
100671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100672       };
100673     } catch (std::exception& e) {
100674       {
100675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100676       };
100677     } catch (Dali::DaliException e) {
100678       {
100679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100680       };
100681     } catch (...) {
100682       {
100683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100684       };
100685     }
100686   }
100687
100688 }
100689
100690 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100691   Dali::RefObject *result = NULL;
100692
100693   if (arg1)
100694   {
100695     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100696   }
100697   return result;
100698 }
100699
100700 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100701     return (Dali::RefObject *)jarg1;
100702 }
100703
100704 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100705     return (Dali::SignalObserver *)jarg1;
100706 }
100707
100708 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100709     return (Dali::ConnectionTrackerInterface *)jarg1;
100710 }
100711
100712 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100713     return (Dali::BaseHandle *)jarg1;
100714 }
100715
100716 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100717     return (Dali::BaseHandle *)jarg1;
100718 }
100719
100720 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100721     return (Dali::BaseHandle *)jarg1;
100722 }
100723
100724 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100725     return (Dali::BaseHandle *)jarg1;
100726 }
100727
100728 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100729     return (Dali::BaseHandle *)jarg1;
100730 }
100731
100732 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100733     return (Dali::BaseHandle *)jarg1;
100734 }
100735
100736 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100737     return (Dali::BaseHandle *)jarg1;
100738 }
100739
100740 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100741     return (Dali::BaseHandle *)jarg1;
100742 }
100743
100744 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100745     return (Dali::BaseHandle *)jarg1;
100746 }
100747
100748 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100749     return (Dali::BaseHandle *)jarg1;
100750 }
100751
100752 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100753     return (Dali::BaseHandle *)jarg1;
100754 }
100755
100756 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100757     return (Dali::BaseHandle *)jarg1;
100758 }
100759
100760 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100761     return (Dali::BaseHandle *)jarg1;
100762 }
100763
100764 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100765     return (Dali::Handle *)jarg1;
100766 }
100767
100768 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100769     return (Dali::Handle *)jarg1;
100770 }
100771
100772 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100773     return (Dali::BaseHandle *)jarg1;
100774 }
100775
100776 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100777     return (Dali::BaseHandle *)jarg1;
100778 }
100779
100780 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100781     return (Dali::Handle *)jarg1;
100782 }
100783
100784 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100785     return (Dali::BaseHandle *)jarg1;
100786 }
100787
100788 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100789     return (Dali::Handle *)jarg1;
100790 }
100791
100792 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100793     return (Dali::GestureDetector *)jarg1;
100794 }
100795
100796 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100797     return (Dali::Gesture *)jarg1;
100798 }
100799
100800 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100801     return (Dali::Handle *)jarg1;
100802 }
100803
100804 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100805     return (Dali::Actor *)jarg1;
100806 }
100807
100808 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100809     return (Dali::BaseHandle *)jarg1;
100810 }
100811
100812 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100813     return (Dali::RefObject *)jarg1;
100814 }
100815
100816 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100817     return (Dali::Actor *)jarg1;
100818 }
100819
100820 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100821     return (Dali::GestureDetector *)jarg1;
100822 }
100823
100824 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100825     return (Dali::Gesture *)jarg1;
100826 }
100827
100828 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100829     return (Dali::GestureDetector *)jarg1;
100830 }
100831
100832 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100833     return (Dali::Gesture *)jarg1;
100834 }
100835
100836 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100837     return (Dali::GestureDetector *)jarg1;
100838 }
100839
100840 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100841     return (Dali::Gesture *)jarg1;
100842 }
100843
100844 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100845     return (Dali::BaseHandle *)jarg1;
100846 }
100847
100848 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100849     return (Dali::Handle *)jarg1;
100850 }
100851
100852 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100853     return (Dali::Handle *)jarg1;
100854 }
100855
100856 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100857     return (Dali::Handle *)jarg1;
100858 }
100859
100860 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100861     return (Dali::Image *)jarg1;
100862 }
100863
100864 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100865     return (Dali::Image *)jarg1;
100866 }
100867
100868 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100869     return (Dali::Image *)jarg1;
100870 }
100871
100872 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100873     return (Dali::RefObject *)jarg1;
100874 }
100875
100876 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100877     return (Dali::Image *)jarg1;
100878 }
100879
100880 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100881     return (Dali::Image *)jarg1;
100882 }
100883
100884 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100885     return (Dali::ResourceImage *)jarg1;
100886 }
100887
100888 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100889     return (Dali::Actor *)jarg1;
100890 }
100891
100892 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100893     return (Dali::BaseHandle *)jarg1;
100894 }
100895
100896 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
100897     return (Dali::BaseHandle *)jarg1;
100898 }
100899
100900
100901 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100902     return (Dali::BaseHandle *)jarg1;
100903 }
100904
100905 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100906     return (Dali::BaseHandle *)jarg1;
100907 }
100908
100909 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100910     return (Dali::CustomActorImpl *)jarg1;
100911 }
100912
100913 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100914     return (Dali::CustomActor *)jarg1;
100915 }
100916
100917 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100918     return (Dali::BaseHandle *)jarg1;
100919 }
100920
100921 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100922     return (Dali::Toolkit::Control *)jarg1;
100923 }
100924
100925 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100926     return (Dali::Toolkit::Control *)jarg1;
100927 }
100928
100929 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100930     return (Dali::Toolkit::Button *)jarg1;
100931 }
100932
100933 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100934     return (Dali::Toolkit::Button *)jarg1;
100935 }
100936
100937 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100938     return (Dali::Toolkit::Button *)jarg1;
100939 }
100940
100941 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100942     return (Dali::Toolkit::Control *)jarg1;
100943 }
100944
100945 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100946     return (Dali::Toolkit::Control *)jarg1;
100947 }
100948
100949 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100950     return (Dali::Toolkit::Control *)jarg1;
100951 }
100952
100953 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100954     return (Dali::Toolkit::Control *)jarg1;
100955 }
100956
100957 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100958     return (Dali::Toolkit::Control *)jarg1;
100959 }
100960
100961 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100962     return (Dali::RefObject *)jarg1;
100963 }
100964
100965 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100966     return (Dali::Toolkit::Scrollable *)jarg1;
100967 }
100968
100969 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100970     return (Dali::BaseHandle *)jarg1;
100971 }
100972
100973 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100974     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100975 }
100976
100977 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100978     return (Dali::RefObject *)jarg1;
100979 }
100980
100981 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100982     return (Dali::Toolkit::Ruler *)jarg1;
100983 }
100984
100985 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100986     return (Dali::Toolkit::Ruler *)jarg1;
100987 }
100988
100989 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100990     return (Dali::Toolkit::Scrollable *)jarg1;
100991 }
100992
100993 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100994     return (Dali::Toolkit::Control *)jarg1;
100995 }
100996
100997
100998 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
100999     return (Dali::Toolkit::Control *)jarg1;
101000 }
101001
101002 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101003     return (Dali::BaseHandle *)jarg1;
101004 }
101005
101006 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101007     return (Dali::BaseHandle *)jarg1;
101008 }
101009
101010 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101011     return (Dali::Toolkit::Control *)jarg1;
101012 }
101013
101014 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101015     return (Dali::Toolkit::Control *)jarg1;
101016 }
101017
101018 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101019     return (Dali::Toolkit::Control *)jarg1;
101020 }
101021
101022 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101023     return (Dali::Toolkit::Control *)jarg1;
101024 }
101025
101026 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101027     return (Dali::Toolkit::Control *)jarg1;
101028 }
101029
101030 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101031     return (Dali::Toolkit::Control *)jarg1;
101032 }
101033
101034 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101035     return (Dali::Toolkit::PageTurnView *)jarg1;
101036 }
101037
101038 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101039     return (Dali::Toolkit::PageTurnView *)jarg1;
101040 }
101041
101042 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101043     return (Dali::Toolkit::Button *)jarg1;
101044 }
101045
101046 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101047     return (Dali::BaseHandle *)jarg1;
101048 }
101049
101050 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101051     return (Dali::BaseHandle *)jarg1;
101052 }
101053
101054 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101055     return (Dali::BaseHandle *)jarg1;
101056 }
101057
101058
101059 #ifdef __cplusplus
101060 }
101061 #endif
101062