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::ImageVisual::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::ImageVisual::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::ImageVisual::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_URL_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::Property::Index arg2 = 0 ;
68156   arg2 = (Dali::Property::Index)jarg2;
68157
68158   Toolkit::Visual::ResourceStatus result;
68159   {
68160     try {
68161       result = arg1->GetVisualResourceStatus(arg2);
68162     } catch (std::out_of_range& e) {
68163       {
68164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68165       };
68166     } catch (std::exception& e) {
68167       {
68168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68169       };
68170     } catch (...) {
68171       {
68172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68173       };
68174     }
68175   }
68176   jresult = (int)(result);
68177   return jresult;
68178 }
68179
68180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68181 {
68182   void * jresult;
68183   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68184   arg1 = (Dali::Toolkit::Control *)jarg1;
68185
68186   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68187
68188   Dali::Toolkit::TransitionData *arg2 = 0 ;
68189   Dali::Animation result;
68190
68191   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68192   if (!arg2) {
68193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68194     return 0;
68195   }
68196   {
68197     try {
68198       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68199     } catch (std::out_of_range& e) {
68200       {
68201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68202       };
68203     } catch (std::exception& e) {
68204       {
68205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68206       };
68207     } catch (Dali::DaliException e) {
68208       {
68209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68210       };
68211     } catch (...) {
68212       {
68213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68214       };
68215     }
68216   }
68217
68218   jresult = new Dali::Animation((const Dali::Animation &)result);
68219   return jresult;
68220 }
68221
68222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68223 {
68224   Dali::Toolkit::Control arg1;
68225   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68226
68227   if (!argp1) {
68228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68229   }
68230   arg1 = *argp1;
68231
68232   Dali::Property::Index arg2 = 0 ;
68233   arg2 = (Dali::Property::Index)jarg2;
68234
68235   Dali::Property::Index arg3 = 0 ;
68236   arg3 = (Dali::Property::Index)jarg3;
68237
68238   Dali::Property::Value arg4;
68239   arg4 = (Dali::Property::Value *)jarg4;
68240
68241   {
68242     try {
68243       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68244     } catch (std::out_of_range& e) {
68245       {
68246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68247       };
68248     } catch (std::exception& e) {
68249       {
68250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68251       };
68252     } catch (...) {
68253       {
68254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68255       };
68256     }
68257   }
68258
68259
68260 }
68261
68262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68263   void * jresult ;
68264   Dali::Toolkit::Control *arg1 = 0 ;
68265   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68266
68267   arg1 = (Dali::Toolkit::Control *)jarg1;
68268   if (!arg1) {
68269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68270     return 0;
68271   }
68272   {
68273     try {
68274       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68275     } catch (std::out_of_range& e) {
68276       {
68277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68278       };
68279     } catch (std::exception& e) {
68280       {
68281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68282       };
68283     } catch (Dali::DaliException e) {
68284       {
68285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68286       };
68287     } catch (...) {
68288       {
68289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68290       };
68291     }
68292   }
68293
68294   jresult = (void *)result;
68295   return jresult;
68296 }
68297
68298
68299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68300   unsigned int jresult ;
68301   Dali::Toolkit::Control *arg1 = 0 ;
68302   bool result;
68303
68304   arg1 = (Dali::Toolkit::Control *)jarg1;
68305   if (!arg1) {
68306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68307     return 0;
68308   }
68309   {
68310     try {
68311       result = (bool)arg1->IsResourceReady();
68312     } catch (std::out_of_range& e) {
68313       {
68314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68315       };
68316     } catch (std::exception& e) {
68317       {
68318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68319       };
68320     } catch (Dali::DaliException e) {
68321       {
68322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68323       };
68324     } catch (...) {
68325       {
68326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68327       };
68328     }
68329   }
68330
68331   jresult = result;
68332   return jresult;
68333 }
68334
68335
68336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68337   void * jresult ;
68338   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68339
68340   {
68341     try {
68342       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68343     } catch (std::out_of_range& e) {
68344       {
68345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68346       };
68347     } catch (std::exception& e) {
68348       {
68349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68350       };
68351     } catch (Dali::DaliException e) {
68352       {
68353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68354       };
68355     } catch (...) {
68356       {
68357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68358       };
68359     }
68360   }
68361
68362   jresult = (void *)result;
68363   return jresult;
68364 }
68365
68366
68367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68368   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68369
68370   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68371   {
68372     try {
68373       delete arg1;
68374     } catch (std::out_of_range& e) {
68375       {
68376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68377       };
68378     } catch (std::exception& e) {
68379       {
68380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68381       };
68382     } catch (Dali::DaliException e) {
68383       {
68384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68385       };
68386     } catch (...) {
68387       {
68388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68389       };
68390     }
68391   }
68392
68393 }
68394
68395
68396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68397   void * jresult ;
68398   Dali::Toolkit::KeyInputFocusManager result;
68399
68400   {
68401     try {
68402       result = Dali::Toolkit::KeyInputFocusManager::Get();
68403     } catch (std::out_of_range& e) {
68404       {
68405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68406       };
68407     } catch (std::exception& e) {
68408       {
68409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68410       };
68411     } catch (Dali::DaliException e) {
68412       {
68413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68414       };
68415     } catch (...) {
68416       {
68417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68418       };
68419     }
68420   }
68421
68422   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68423   return jresult;
68424 }
68425
68426
68427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68428   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68429   Dali::Toolkit::Control arg2 ;
68430   Dali::Toolkit::Control *argp2 ;
68431
68432   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68433   argp2 = (Dali::Toolkit::Control *)jarg2;
68434   if (!argp2) {
68435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68436     return ;
68437   }
68438   arg2 = *argp2;
68439   {
68440     try {
68441       (arg1)->SetFocus(arg2);
68442     } catch (std::out_of_range& e) {
68443       {
68444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68445       };
68446     } catch (std::exception& e) {
68447       {
68448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68449       };
68450     } catch (Dali::DaliException e) {
68451       {
68452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68453       };
68454     } catch (...) {
68455       {
68456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68457       };
68458     }
68459   }
68460
68461 }
68462
68463
68464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68465   void * jresult ;
68466   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68467   Dali::Toolkit::Control result;
68468
68469   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68470   {
68471     try {
68472       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68473     } catch (std::out_of_range& e) {
68474       {
68475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68476       };
68477     } catch (std::exception& e) {
68478       {
68479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68480       };
68481     } catch (Dali::DaliException e) {
68482       {
68483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68484       };
68485     } catch (...) {
68486       {
68487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68488       };
68489     }
68490   }
68491
68492   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68493   return jresult;
68494 }
68495
68496
68497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68498   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68499   Dali::Toolkit::Control arg2 ;
68500   Dali::Toolkit::Control *argp2 ;
68501
68502   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68503   argp2 = (Dali::Toolkit::Control *)jarg2;
68504   if (!argp2) {
68505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68506     return ;
68507   }
68508   arg2 = *argp2;
68509   {
68510     try {
68511       (arg1)->RemoveFocus(arg2);
68512     } catch (std::out_of_range& e) {
68513       {
68514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68515       };
68516     } catch (std::exception& e) {
68517       {
68518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68519       };
68520     } catch (Dali::DaliException e) {
68521       {
68522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68523       };
68524     } catch (...) {
68525       {
68526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68527       };
68528     }
68529   }
68530
68531 }
68532
68533
68534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68535   void * jresult ;
68536   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68537   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68538
68539   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68540   {
68541     try {
68542       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68543     } catch (std::out_of_range& e) {
68544       {
68545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68546       };
68547     } catch (std::exception& e) {
68548       {
68549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68550       };
68551     } catch (Dali::DaliException e) {
68552       {
68553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68554       };
68555     } catch (...) {
68556       {
68557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68558       };
68559     }
68560   }
68561
68562   jresult = (void *)result;
68563   return jresult;
68564 }
68565
68566
68567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68568   void * jresult ;
68569   Dali::Toolkit::Alignment::Padding *result = 0 ;
68570
68571   {
68572     try {
68573       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68574     } catch (std::out_of_range& e) {
68575       {
68576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68577       };
68578     } catch (std::exception& e) {
68579       {
68580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68581       };
68582     } catch (Dali::DaliException e) {
68583       {
68584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68585       };
68586     } catch (...) {
68587       {
68588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68589       };
68590     }
68591   }
68592
68593   jresult = (void *)result;
68594   return jresult;
68595 }
68596
68597
68598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68599   void * jresult ;
68600   float arg1 ;
68601   float arg2 ;
68602   float arg3 ;
68603   float arg4 ;
68604   Dali::Toolkit::Alignment::Padding *result = 0 ;
68605
68606   arg1 = (float)jarg1;
68607   arg2 = (float)jarg2;
68608   arg3 = (float)jarg3;
68609   arg4 = (float)jarg4;
68610   {
68611     try {
68612       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68613     } catch (std::out_of_range& e) {
68614       {
68615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68616       };
68617     } catch (std::exception& e) {
68618       {
68619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68620       };
68621     } catch (Dali::DaliException e) {
68622       {
68623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68624       };
68625     } catch (...) {
68626       {
68627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68628       };
68629     }
68630   }
68631
68632   jresult = (void *)result;
68633   return jresult;
68634 }
68635
68636
68637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68638   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68639   float arg2 ;
68640
68641   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68642   arg2 = (float)jarg2;
68643   if (arg1) (arg1)->left = arg2;
68644 }
68645
68646
68647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68648   float jresult ;
68649   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68650   float result;
68651
68652   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68653   result = (float) ((arg1)->left);
68654   jresult = result;
68655   return jresult;
68656 }
68657
68658
68659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68660   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68661   float arg2 ;
68662
68663   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68664   arg2 = (float)jarg2;
68665   if (arg1) (arg1)->right = arg2;
68666 }
68667
68668
68669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68670   float jresult ;
68671   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68672   float result;
68673
68674   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68675   result = (float) ((arg1)->right);
68676   jresult = result;
68677   return jresult;
68678 }
68679
68680
68681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68682   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68683   float arg2 ;
68684
68685   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68686   arg2 = (float)jarg2;
68687   if (arg1) (arg1)->top = arg2;
68688 }
68689
68690
68691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68692   float jresult ;
68693   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68694   float result;
68695
68696   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68697   result = (float) ((arg1)->top);
68698   jresult = result;
68699   return jresult;
68700 }
68701
68702
68703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68704   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68705   float arg2 ;
68706
68707   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68708   arg2 = (float)jarg2;
68709   if (arg1) (arg1)->bottom = arg2;
68710 }
68711
68712
68713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68714   float jresult ;
68715   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68716   float result;
68717
68718   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68719   result = (float) ((arg1)->bottom);
68720   jresult = result;
68721   return jresult;
68722 }
68723
68724
68725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68726   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68727
68728   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68729   {
68730     try {
68731       delete arg1;
68732     } catch (std::out_of_range& e) {
68733       {
68734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68735       };
68736     } catch (std::exception& e) {
68737       {
68738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68739       };
68740     } catch (Dali::DaliException e) {
68741       {
68742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68743       };
68744     } catch (...) {
68745       {
68746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68747       };
68748     }
68749   }
68750
68751 }
68752
68753
68754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68755   void * jresult ;
68756   Dali::Toolkit::Alignment *result = 0 ;
68757
68758   {
68759     try {
68760       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68761     } catch (std::out_of_range& e) {
68762       {
68763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68764       };
68765     } catch (std::exception& e) {
68766       {
68767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68768       };
68769     } catch (Dali::DaliException e) {
68770       {
68771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68772       };
68773     } catch (...) {
68774       {
68775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68776       };
68777     }
68778   }
68779
68780   jresult = (void *)result;
68781   return jresult;
68782 }
68783
68784
68785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68786   void * jresult ;
68787   Dali::Toolkit::Alignment::Type arg1 ;
68788   Dali::Toolkit::Alignment::Type arg2 ;
68789   Dali::Toolkit::Alignment result;
68790
68791   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68792   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68793   {
68794     try {
68795       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68796     } catch (std::out_of_range& e) {
68797       {
68798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68799       };
68800     } catch (std::exception& e) {
68801       {
68802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68803       };
68804     } catch (Dali::DaliException e) {
68805       {
68806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68807       };
68808     } catch (...) {
68809       {
68810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68811       };
68812     }
68813   }
68814
68815   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68816   return jresult;
68817 }
68818
68819
68820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68821   void * jresult ;
68822   Dali::Toolkit::Alignment::Type arg1 ;
68823   Dali::Toolkit::Alignment result;
68824
68825   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68826   {
68827     try {
68828       result = Dali::Toolkit::Alignment::New(arg1);
68829     } catch (std::out_of_range& e) {
68830       {
68831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68832       };
68833     } catch (std::exception& e) {
68834       {
68835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68836       };
68837     } catch (Dali::DaliException e) {
68838       {
68839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68840       };
68841     } catch (...) {
68842       {
68843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68844       };
68845     }
68846   }
68847
68848   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68849   return jresult;
68850 }
68851
68852
68853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68854   void * jresult ;
68855   Dali::Toolkit::Alignment result;
68856
68857   {
68858     try {
68859       result = Dali::Toolkit::Alignment::New();
68860     } catch (std::out_of_range& e) {
68861       {
68862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68863       };
68864     } catch (std::exception& e) {
68865       {
68866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68867       };
68868     } catch (Dali::DaliException e) {
68869       {
68870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68871       };
68872     } catch (...) {
68873       {
68874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68875       };
68876     }
68877   }
68878
68879   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68880   return jresult;
68881 }
68882
68883
68884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68885   void * jresult ;
68886   Dali::Toolkit::Alignment *arg1 = 0 ;
68887   Dali::Toolkit::Alignment *result = 0 ;
68888
68889   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68890   if (!arg1) {
68891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68892     return 0;
68893   }
68894   {
68895     try {
68896       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68897     } catch (std::out_of_range& e) {
68898       {
68899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68900       };
68901     } catch (std::exception& e) {
68902       {
68903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68904       };
68905     } catch (Dali::DaliException e) {
68906       {
68907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68908       };
68909     } catch (...) {
68910       {
68911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68912       };
68913     }
68914   }
68915
68916   jresult = (void *)result;
68917   return jresult;
68918 }
68919
68920
68921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68922   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68923
68924   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68925   {
68926     try {
68927       delete arg1;
68928     } catch (std::out_of_range& e) {
68929       {
68930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68931       };
68932     } catch (std::exception& e) {
68933       {
68934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68935       };
68936     } catch (Dali::DaliException e) {
68937       {
68938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68939       };
68940     } catch (...) {
68941       {
68942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68943       };
68944     }
68945   }
68946
68947 }
68948
68949
68950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68951   void * jresult ;
68952   Dali::BaseHandle arg1 ;
68953   Dali::BaseHandle *argp1 ;
68954   Dali::Toolkit::Alignment result;
68955
68956   argp1 = (Dali::BaseHandle *)jarg1;
68957   if (!argp1) {
68958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68959     return 0;
68960   }
68961   arg1 = *argp1;
68962   {
68963     try {
68964       result = Dali::Toolkit::Alignment::DownCast(arg1);
68965     } catch (std::out_of_range& e) {
68966       {
68967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68968       };
68969     } catch (std::exception& e) {
68970       {
68971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68972       };
68973     } catch (Dali::DaliException e) {
68974       {
68975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68976       };
68977     } catch (...) {
68978       {
68979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68980       };
68981     }
68982   }
68983
68984   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68985   return jresult;
68986 }
68987
68988
68989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68990   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68991   Dali::Toolkit::Alignment::Type arg2 ;
68992
68993   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68994   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68995   {
68996     try {
68997       (arg1)->SetAlignmentType(arg2);
68998     } catch (std::out_of_range& e) {
68999       {
69000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69001       };
69002     } catch (std::exception& e) {
69003       {
69004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69005       };
69006     } catch (Dali::DaliException e) {
69007       {
69008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69009       };
69010     } catch (...) {
69011       {
69012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69013       };
69014     }
69015   }
69016
69017 }
69018
69019
69020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69021   int jresult ;
69022   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69023   Dali::Toolkit::Alignment::Type result;
69024
69025   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69026   {
69027     try {
69028       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69029     } catch (std::out_of_range& e) {
69030       {
69031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69032       };
69033     } catch (std::exception& e) {
69034       {
69035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69036       };
69037     } catch (Dali::DaliException e) {
69038       {
69039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69040       };
69041     } catch (...) {
69042       {
69043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69044       };
69045     }
69046   }
69047
69048   jresult = (int)result;
69049   return jresult;
69050 }
69051
69052
69053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69054   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69055   Dali::Toolkit::Alignment::Scaling arg2 ;
69056
69057   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69058   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69059   {
69060     try {
69061       (arg1)->SetScaling(arg2);
69062     } catch (std::out_of_range& e) {
69063       {
69064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69065       };
69066     } catch (std::exception& e) {
69067       {
69068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69069       };
69070     } catch (Dali::DaliException e) {
69071       {
69072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69073       };
69074     } catch (...) {
69075       {
69076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69077       };
69078     }
69079   }
69080
69081 }
69082
69083
69084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69085   int jresult ;
69086   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69087   Dali::Toolkit::Alignment::Scaling result;
69088
69089   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69090   {
69091     try {
69092       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69093     } catch (std::out_of_range& e) {
69094       {
69095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69096       };
69097     } catch (std::exception& e) {
69098       {
69099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69100       };
69101     } catch (Dali::DaliException e) {
69102       {
69103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69104       };
69105     } catch (...) {
69106       {
69107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69108       };
69109     }
69110   }
69111
69112   jresult = (int)result;
69113   return jresult;
69114 }
69115
69116
69117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69118   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69119   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69120
69121   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69122   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69123   if (!arg2) {
69124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69125     return ;
69126   }
69127   {
69128     try {
69129       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69130     } catch (std::out_of_range& e) {
69131       {
69132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69133       };
69134     } catch (std::exception& e) {
69135       {
69136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69137       };
69138     } catch (Dali::DaliException e) {
69139       {
69140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69141       };
69142     } catch (...) {
69143       {
69144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69145       };
69146     }
69147   }
69148
69149 }
69150
69151
69152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69153   void * jresult ;
69154   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69155   Dali::Toolkit::Alignment::Padding *result = 0 ;
69156
69157   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69158   {
69159     try {
69160       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69161     } catch (std::out_of_range& e) {
69162       {
69163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69164       };
69165     } catch (std::exception& e) {
69166       {
69167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69168       };
69169     } catch (Dali::DaliException e) {
69170       {
69171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69172       };
69173     } catch (...) {
69174       {
69175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69176       };
69177     }
69178   }
69179
69180   jresult = (void *)result;
69181   return jresult;
69182 }
69183
69184
69185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69186   void * jresult ;
69187   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69188   Dali::Toolkit::Alignment *arg2 = 0 ;
69189   Dali::Toolkit::Alignment *result = 0 ;
69190
69191   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69192   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69193   if (!arg2) {
69194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69195     return 0;
69196   }
69197   {
69198     try {
69199       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69200     } catch (std::out_of_range& e) {
69201       {
69202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69203       };
69204     } catch (std::exception& e) {
69205       {
69206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69207       };
69208     } catch (Dali::DaliException e) {
69209       {
69210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69211       };
69212     } catch (...) {
69213       {
69214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69215       };
69216     }
69217   }
69218
69219   jresult = (void *)result;
69220   return jresult;
69221 }
69222
69223
69224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69225   int jresult ;
69226   int result;
69227
69228   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69229   jresult = (int)result;
69230   return jresult;
69231 }
69232
69233
69234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69235   int jresult ;
69236   int result;
69237
69238   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69239   jresult = (int)result;
69240   return jresult;
69241 }
69242
69243
69244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69245   int jresult ;
69246   int result;
69247
69248   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69249   jresult = (int)result;
69250   return jresult;
69251 }
69252
69253
69254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69255   int jresult ;
69256   int result;
69257
69258   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69259   jresult = (int)result;
69260   return jresult;
69261 }
69262
69263
69264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69265   int jresult ;
69266   int result;
69267
69268   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69269   jresult = (int)result;
69270   return jresult;
69271 }
69272
69273
69274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69275   int jresult ;
69276   int result;
69277
69278   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69279   jresult = (int)result;
69280   return jresult;
69281 }
69282
69283
69284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69285   int jresult ;
69286   int result;
69287
69288   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69289   jresult = (int)result;
69290   return jresult;
69291 }
69292
69293
69294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69295   int jresult ;
69296   int result;
69297
69298   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69299   jresult = (int)result;
69300   return jresult;
69301 }
69302
69303
69304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69305   int jresult ;
69306   int result;
69307
69308   result = (int)Dali::Toolkit::Button::Property::LABEL;
69309   jresult = (int)result;
69310   return jresult;
69311 }
69312
69313
69314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69315   int jresult ;
69316   int result;
69317
69318   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69319   jresult = (int)result;
69320   return jresult;
69321 }
69322
69323
69324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69325   void * jresult ;
69326   Dali::Toolkit::Button::Property *result = 0 ;
69327
69328   {
69329     try {
69330       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69331     } catch (std::out_of_range& e) {
69332       {
69333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69334       };
69335     } catch (std::exception& e) {
69336       {
69337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69338       };
69339     } catch (Dali::DaliException e) {
69340       {
69341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69342       };
69343     } catch (...) {
69344       {
69345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69346       };
69347     }
69348   }
69349
69350   jresult = (void *)result;
69351   return jresult;
69352 }
69353
69354
69355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69356   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69357
69358   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69359   {
69360     try {
69361       delete arg1;
69362     } catch (std::out_of_range& e) {
69363       {
69364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69365       };
69366     } catch (std::exception& e) {
69367       {
69368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69369       };
69370     } catch (Dali::DaliException e) {
69371       {
69372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69373       };
69374     } catch (...) {
69375       {
69376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69377       };
69378     }
69379   }
69380
69381 }
69382
69383
69384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69385   void * jresult ;
69386   Dali::Toolkit::Button *result = 0 ;
69387
69388   {
69389     try {
69390       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69391     } catch (std::out_of_range& e) {
69392       {
69393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69394       };
69395     } catch (std::exception& e) {
69396       {
69397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69398       };
69399     } catch (Dali::DaliException e) {
69400       {
69401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69402       };
69403     } catch (...) {
69404       {
69405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69406       };
69407     }
69408   }
69409
69410   jresult = (void *)result;
69411   return jresult;
69412 }
69413
69414
69415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69416   void * jresult ;
69417   Dali::Toolkit::Button *arg1 = 0 ;
69418   Dali::Toolkit::Button *result = 0 ;
69419
69420   arg1 = (Dali::Toolkit::Button *)jarg1;
69421   if (!arg1) {
69422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69423     return 0;
69424   }
69425   {
69426     try {
69427       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69428     } catch (std::out_of_range& e) {
69429       {
69430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69431       };
69432     } catch (std::exception& e) {
69433       {
69434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69435       };
69436     } catch (Dali::DaliException e) {
69437       {
69438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69439       };
69440     } catch (...) {
69441       {
69442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69443       };
69444     }
69445   }
69446
69447   jresult = (void *)result;
69448   return jresult;
69449 }
69450
69451
69452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69453   void * jresult ;
69454   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69455   Dali::Toolkit::Button *arg2 = 0 ;
69456   Dali::Toolkit::Button *result = 0 ;
69457
69458   arg1 = (Dali::Toolkit::Button *)jarg1;
69459   arg2 = (Dali::Toolkit::Button *)jarg2;
69460   if (!arg2) {
69461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69462     return 0;
69463   }
69464   {
69465     try {
69466       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69467     } catch (std::out_of_range& e) {
69468       {
69469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69470       };
69471     } catch (std::exception& e) {
69472       {
69473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69474       };
69475     } catch (Dali::DaliException e) {
69476       {
69477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69478       };
69479     } catch (...) {
69480       {
69481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69482       };
69483     }
69484   }
69485
69486   jresult = (void *)result;
69487   return jresult;
69488 }
69489
69490
69491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69492   void * jresult ;
69493   Dali::BaseHandle arg1 ;
69494   Dali::BaseHandle *argp1 ;
69495   Dali::Toolkit::Button result;
69496
69497   argp1 = (Dali::BaseHandle *)jarg1;
69498   if (!argp1) {
69499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69500     return 0;
69501   }
69502   arg1 = *argp1;
69503   {
69504     try {
69505       result = Dali::Toolkit::Button::DownCast(arg1);
69506     } catch (std::out_of_range& e) {
69507       {
69508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69509       };
69510     } catch (std::exception& e) {
69511       {
69512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69513       };
69514     } catch (Dali::DaliException e) {
69515       {
69516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69517       };
69518     } catch (...) {
69519       {
69520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69521       };
69522     }
69523   }
69524
69525   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69526   return jresult;
69527 }
69528
69529
69530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69531   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69532
69533   arg1 = (Dali::Toolkit::Button *)jarg1;
69534   {
69535     try {
69536       delete arg1;
69537     } catch (std::out_of_range& e) {
69538       {
69539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69540       };
69541     } catch (std::exception& e) {
69542       {
69543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69544       };
69545     } catch (Dali::DaliException e) {
69546       {
69547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69548       };
69549     } catch (...) {
69550       {
69551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69552       };
69553     }
69554   }
69555
69556 }
69557
69558
69559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69560   unsigned int jresult ;
69561   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69562   bool result;
69563
69564   arg1 = (Dali::Toolkit::Button *)jarg1;
69565   {
69566     try {
69567       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69568     } catch (std::out_of_range& e) {
69569       {
69570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69571       };
69572     } catch (std::exception& e) {
69573       {
69574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69575       };
69576     } catch (Dali::DaliException e) {
69577       {
69578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69579       };
69580     } catch (...) {
69581       {
69582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69583       };
69584     }
69585   }
69586
69587   jresult = result;
69588   return jresult;
69589 }
69590
69591
69592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69593   unsigned int jresult ;
69594   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69595   bool result;
69596
69597   arg1 = (Dali::Toolkit::Button *)jarg1;
69598   {
69599     try {
69600       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69601     } catch (std::out_of_range& e) {
69602       {
69603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69604       };
69605     } catch (std::exception& e) {
69606       {
69607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69608       };
69609     } catch (Dali::DaliException e) {
69610       {
69611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69612       };
69613     } catch (...) {
69614       {
69615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69616       };
69617     }
69618   }
69619
69620   jresult = result;
69621   return jresult;
69622 }
69623
69624
69625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69626   float jresult ;
69627   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69628   float result;
69629
69630   arg1 = (Dali::Toolkit::Button *)jarg1;
69631   {
69632     try {
69633       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69634     } catch (std::out_of_range& e) {
69635       {
69636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69637       };
69638     } catch (std::exception& e) {
69639       {
69640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69641       };
69642     } catch (Dali::DaliException e) {
69643       {
69644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69645       };
69646     } catch (...) {
69647       {
69648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69649       };
69650     }
69651   }
69652
69653   jresult = result;
69654   return jresult;
69655 }
69656
69657
69658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69659   float jresult ;
69660   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69661   float result;
69662
69663   arg1 = (Dali::Toolkit::Button *)jarg1;
69664   {
69665     try {
69666       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69667     } catch (std::out_of_range& e) {
69668       {
69669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69670       };
69671     } catch (std::exception& e) {
69672       {
69673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69674       };
69675     } catch (Dali::DaliException e) {
69676       {
69677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69678       };
69679     } catch (...) {
69680       {
69681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69682       };
69683     }
69684   }
69685
69686   jresult = result;
69687   return jresult;
69688 }
69689
69690
69691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69692   unsigned int jresult ;
69693   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69694   bool result;
69695
69696   arg1 = (Dali::Toolkit::Button *)jarg1;
69697   {
69698     try {
69699       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69700     } catch (std::out_of_range& e) {
69701       {
69702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69703       };
69704     } catch (std::exception& e) {
69705       {
69706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69707       };
69708     } catch (Dali::DaliException e) {
69709       {
69710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69711       };
69712     } catch (...) {
69713       {
69714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69715       };
69716     }
69717   }
69718
69719   jresult = result;
69720   return jresult;
69721 }
69722
69723
69724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69725   unsigned int jresult ;
69726   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69727   bool result;
69728
69729   arg1 = (Dali::Toolkit::Button *)jarg1;
69730   {
69731     try {
69732       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69733     } catch (std::out_of_range& e) {
69734       {
69735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69736       };
69737     } catch (std::exception& e) {
69738       {
69739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69740       };
69741     } catch (Dali::DaliException e) {
69742       {
69743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69744       };
69745     } catch (...) {
69746       {
69747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69748       };
69749     }
69750   }
69751
69752   jresult = result;
69753   return jresult;
69754 }
69755
69756
69757 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69758   float jresult ;
69759   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69760   float result;
69761
69762   arg1 = (Dali::Toolkit::Button *)jarg1;
69763   {
69764     try {
69765       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69766     } catch (std::out_of_range& e) {
69767       {
69768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69769       };
69770     } catch (std::exception& e) {
69771       {
69772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69773       };
69774     } catch (Dali::DaliException e) {
69775       {
69776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69777       };
69778     } catch (...) {
69779       {
69780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69781       };
69782     }
69783   }
69784
69785   jresult = result;
69786   return jresult;
69787 }
69788
69789
69790 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69791   char * jresult ;
69792   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69793   std::string result;
69794
69795   arg1 = (Dali::Toolkit::Button *)jarg1;
69796   {
69797     try {
69798       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69799     } catch (std::out_of_range& e) {
69800       {
69801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69802       };
69803     } catch (std::exception& e) {
69804       {
69805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69806       };
69807     } catch (Dali::DaliException e) {
69808       {
69809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69810       };
69811     } catch (...) {
69812       {
69813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69814       };
69815     }
69816   }
69817
69818   jresult = SWIG_csharp_string_callback((&result)->c_str());
69819   return jresult;
69820 }
69821
69822
69823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69824   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69825   Dali::Actor arg2 ;
69826   Dali::Actor *argp2 ;
69827
69828   arg1 = (Dali::Toolkit::Button *)jarg1;
69829   argp2 = (Dali::Actor *)jarg2;
69830   if (!argp2) {
69831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69832     return ;
69833   }
69834   arg2 = *argp2;
69835   {
69836     try {
69837       (arg1)->SetLabel(arg2);
69838     } catch (std::out_of_range& e) {
69839       {
69840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69841       };
69842     } catch (std::exception& e) {
69843       {
69844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69845       };
69846     } catch (Dali::DaliException e) {
69847       {
69848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69849       };
69850     } catch (...) {
69851       {
69852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69853       };
69854     }
69855   }
69856
69857 }
69858
69859
69860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69861   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69862   Dali::Image arg2 ;
69863   Dali::Image *argp2 ;
69864
69865   arg1 = (Dali::Toolkit::Button *)jarg1;
69866   argp2 = (Dali::Image *)jarg2;
69867   if (!argp2) {
69868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69869     return ;
69870   }
69871   arg2 = *argp2;
69872   {
69873     try {
69874       (arg1)->SetButtonImage(arg2);
69875     } catch (std::out_of_range& e) {
69876       {
69877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69878       };
69879     } catch (std::exception& e) {
69880       {
69881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69882       };
69883     } catch (Dali::DaliException e) {
69884       {
69885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69886       };
69887     } catch (...) {
69888       {
69889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69890       };
69891     }
69892   }
69893
69894 }
69895
69896
69897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69898   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69899   Dali::Image arg2 ;
69900   Dali::Image *argp2 ;
69901
69902   arg1 = (Dali::Toolkit::Button *)jarg1;
69903   argp2 = (Dali::Image *)jarg2;
69904   if (!argp2) {
69905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69906     return ;
69907   }
69908   arg2 = *argp2;
69909   {
69910     try {
69911       (arg1)->SetSelectedImage(arg2);
69912     } catch (std::out_of_range& e) {
69913       {
69914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69915       };
69916     } catch (std::exception& e) {
69917       {
69918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69919       };
69920     } catch (Dali::DaliException e) {
69921       {
69922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69923       };
69924     } catch (...) {
69925       {
69926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69927       };
69928     }
69929   }
69930
69931 }
69932
69933
69934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69935   void * jresult ;
69936   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69937   Dali::Actor result;
69938
69939   arg1 = (Dali::Toolkit::Button *)jarg1;
69940   {
69941     try {
69942       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69943     } catch (std::out_of_range& e) {
69944       {
69945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69946       };
69947     } catch (std::exception& e) {
69948       {
69949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69950       };
69951     } catch (Dali::DaliException e) {
69952       {
69953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69954       };
69955     } catch (...) {
69956       {
69957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69958       };
69959     }
69960   }
69961
69962   jresult = new Dali::Actor((const Dali::Actor &)result);
69963   return jresult;
69964 }
69965
69966
69967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69968   void * jresult ;
69969   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69970   Dali::Actor result;
69971
69972   arg1 = (Dali::Toolkit::Button *)jarg1;
69973   {
69974     try {
69975       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69976     } catch (std::out_of_range& e) {
69977       {
69978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69979       };
69980     } catch (std::exception& e) {
69981       {
69982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69983       };
69984     } catch (Dali::DaliException e) {
69985       {
69986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69987       };
69988     } catch (...) {
69989       {
69990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69991       };
69992     }
69993   }
69994
69995   jresult = new Dali::Actor((const Dali::Actor &)result);
69996   return jresult;
69997 }
69998
69999
70000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70001   void * jresult ;
70002   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70003   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70004
70005   arg1 = (Dali::Toolkit::Button *)jarg1;
70006   {
70007     try {
70008       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70009     } catch (std::out_of_range& e) {
70010       {
70011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70012       };
70013     } catch (std::exception& e) {
70014       {
70015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70016       };
70017     } catch (Dali::DaliException e) {
70018       {
70019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70020       };
70021     } catch (...) {
70022       {
70023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70024       };
70025     }
70026   }
70027
70028   jresult = (void *)result;
70029   return jresult;
70030 }
70031
70032
70033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70034   void * jresult ;
70035   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70036   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70037
70038   arg1 = (Dali::Toolkit::Button *)jarg1;
70039   {
70040     try {
70041       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70042     } catch (std::out_of_range& e) {
70043       {
70044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70045       };
70046     } catch (std::exception& e) {
70047       {
70048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70049       };
70050     } catch (Dali::DaliException e) {
70051       {
70052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70053       };
70054     } catch (...) {
70055       {
70056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70057       };
70058     }
70059   }
70060
70061   jresult = (void *)result;
70062   return jresult;
70063 }
70064
70065
70066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70067   void * jresult ;
70068   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70069   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70070
70071   arg1 = (Dali::Toolkit::Button *)jarg1;
70072   {
70073     try {
70074       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70075     } catch (std::out_of_range& e) {
70076       {
70077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70078       };
70079     } catch (std::exception& e) {
70080       {
70081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70082       };
70083     } catch (Dali::DaliException e) {
70084       {
70085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70086       };
70087     } catch (...) {
70088       {
70089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70090       };
70091     }
70092   }
70093
70094   jresult = (void *)result;
70095   return jresult;
70096 }
70097
70098
70099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70100   void * jresult ;
70101   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70102   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70103
70104   arg1 = (Dali::Toolkit::Button *)jarg1;
70105   {
70106     try {
70107       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70108     } catch (std::out_of_range& e) {
70109       {
70110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70111       };
70112     } catch (std::exception& e) {
70113       {
70114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70115       };
70116     } catch (Dali::DaliException e) {
70117       {
70118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70119       };
70120     } catch (...) {
70121       {
70122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70123       };
70124     }
70125   }
70126
70127   jresult = (void *)result;
70128   return jresult;
70129 }
70130
70131
70132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70133   void * jresult ;
70134   Dali::Toolkit::CheckBoxButton *result = 0 ;
70135
70136   {
70137     try {
70138       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70139     } catch (std::out_of_range& e) {
70140       {
70141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70142       };
70143     } catch (std::exception& e) {
70144       {
70145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70146       };
70147     } catch (Dali::DaliException e) {
70148       {
70149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70150       };
70151     } catch (...) {
70152       {
70153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70154       };
70155     }
70156   }
70157
70158   jresult = (void *)result;
70159   return jresult;
70160 }
70161
70162
70163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70164   void * jresult ;
70165   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70166   Dali::Toolkit::CheckBoxButton *result = 0 ;
70167
70168   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70169   if (!arg1) {
70170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70171     return 0;
70172   }
70173   {
70174     try {
70175       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70176     } catch (std::out_of_range& e) {
70177       {
70178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70179       };
70180     } catch (std::exception& e) {
70181       {
70182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70183       };
70184     } catch (Dali::DaliException e) {
70185       {
70186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70187       };
70188     } catch (...) {
70189       {
70190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70191       };
70192     }
70193   }
70194
70195   jresult = (void *)result;
70196   return jresult;
70197 }
70198
70199
70200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70201   void * jresult ;
70202   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70203   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70204   Dali::Toolkit::CheckBoxButton *result = 0 ;
70205
70206   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70207   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70208   if (!arg2) {
70209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70210     return 0;
70211   }
70212   {
70213     try {
70214       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70215     } catch (std::out_of_range& e) {
70216       {
70217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70218       };
70219     } catch (std::exception& e) {
70220       {
70221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70222       };
70223     } catch (Dali::DaliException e) {
70224       {
70225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70226       };
70227     } catch (...) {
70228       {
70229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70230       };
70231     }
70232   }
70233
70234   jresult = (void *)result;
70235   return jresult;
70236 }
70237
70238
70239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70240   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70241
70242   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70243   {
70244     try {
70245       delete arg1;
70246     } catch (std::out_of_range& e) {
70247       {
70248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70249       };
70250     } catch (std::exception& e) {
70251       {
70252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70253       };
70254     } catch (Dali::DaliException e) {
70255       {
70256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70257       };
70258     } catch (...) {
70259       {
70260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70261       };
70262     }
70263   }
70264
70265 }
70266
70267
70268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70269   void * jresult ;
70270   Dali::Toolkit::CheckBoxButton result;
70271
70272   {
70273     try {
70274       result = Dali::Toolkit::CheckBoxButton::New();
70275     } catch (std::out_of_range& e) {
70276       {
70277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70278       };
70279     } catch (std::exception& e) {
70280       {
70281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70282       };
70283     } catch (Dali::DaliException e) {
70284       {
70285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70286       };
70287     } catch (...) {
70288       {
70289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70290       };
70291     }
70292   }
70293
70294   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70295   return jresult;
70296 }
70297
70298
70299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70300   void * jresult ;
70301   Dali::BaseHandle arg1 ;
70302   Dali::BaseHandle *argp1 ;
70303   Dali::Toolkit::CheckBoxButton result;
70304
70305   argp1 = (Dali::BaseHandle *)jarg1;
70306   if (!argp1) {
70307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70308     return 0;
70309   }
70310   arg1 = *argp1;
70311   {
70312     try {
70313       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70314     } catch (std::out_of_range& e) {
70315       {
70316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70317       };
70318     } catch (std::exception& e) {
70319       {
70320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70321       };
70322     } catch (Dali::DaliException e) {
70323       {
70324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70325       };
70326     } catch (...) {
70327       {
70328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70329       };
70330     }
70331   }
70332
70333   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70334   return jresult;
70335 }
70336
70337
70338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70339   int jresult ;
70340   int result;
70341
70342   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70343   jresult = (int)result;
70344   return jresult;
70345 }
70346
70347
70348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70349   int jresult ;
70350   int result;
70351
70352   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70353   jresult = (int)result;
70354   return jresult;
70355 }
70356
70357
70358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70359   int jresult ;
70360   int result;
70361
70362   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70363   jresult = (int)result;
70364   return jresult;
70365 }
70366
70367
70368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70369   int jresult ;
70370   int result;
70371
70372   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70373   jresult = (int)result;
70374   return jresult;
70375 }
70376
70377
70378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70379   int jresult ;
70380   int result;
70381
70382   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70383   jresult = (int)result;
70384   return jresult;
70385 }
70386
70387
70388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70389   void * jresult ;
70390   Dali::Toolkit::PushButton::Property *result = 0 ;
70391
70392   {
70393     try {
70394       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70395     } catch (std::out_of_range& e) {
70396       {
70397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70398       };
70399     } catch (std::exception& e) {
70400       {
70401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70402       };
70403     } catch (Dali::DaliException e) {
70404       {
70405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70406       };
70407     } catch (...) {
70408       {
70409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70410       };
70411     }
70412   }
70413
70414   jresult = (void *)result;
70415   return jresult;
70416 }
70417
70418
70419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70420   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70421
70422   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70423   {
70424     try {
70425       delete arg1;
70426     } catch (std::out_of_range& e) {
70427       {
70428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70429       };
70430     } catch (std::exception& e) {
70431       {
70432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70433       };
70434     } catch (Dali::DaliException e) {
70435       {
70436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70437       };
70438     } catch (...) {
70439       {
70440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70441       };
70442     }
70443   }
70444
70445 }
70446
70447
70448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70449   void * jresult ;
70450   Dali::Toolkit::PushButton *result = 0 ;
70451
70452   {
70453     try {
70454       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70455     } catch (std::out_of_range& e) {
70456       {
70457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70458       };
70459     } catch (std::exception& e) {
70460       {
70461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70462       };
70463     } catch (Dali::DaliException e) {
70464       {
70465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70466       };
70467     } catch (...) {
70468       {
70469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70470       };
70471     }
70472   }
70473
70474   jresult = (void *)result;
70475   return jresult;
70476 }
70477
70478
70479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70480   void * jresult ;
70481   Dali::Toolkit::PushButton *arg1 = 0 ;
70482   Dali::Toolkit::PushButton *result = 0 ;
70483
70484   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70485   if (!arg1) {
70486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70487     return 0;
70488   }
70489   {
70490     try {
70491       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70492     } catch (std::out_of_range& e) {
70493       {
70494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70495       };
70496     } catch (std::exception& e) {
70497       {
70498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70499       };
70500     } catch (Dali::DaliException e) {
70501       {
70502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70503       };
70504     } catch (...) {
70505       {
70506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70507       };
70508     }
70509   }
70510
70511   jresult = (void *)result;
70512   return jresult;
70513 }
70514
70515
70516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70517   void * jresult ;
70518   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70519   Dali::Toolkit::PushButton *arg2 = 0 ;
70520   Dali::Toolkit::PushButton *result = 0 ;
70521
70522   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70523   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70524   if (!arg2) {
70525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70526     return 0;
70527   }
70528   {
70529     try {
70530       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70531     } catch (std::out_of_range& e) {
70532       {
70533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70534       };
70535     } catch (std::exception& e) {
70536       {
70537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70538       };
70539     } catch (Dali::DaliException e) {
70540       {
70541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70542       };
70543     } catch (...) {
70544       {
70545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70546       };
70547     }
70548   }
70549
70550   jresult = (void *)result;
70551   return jresult;
70552 }
70553
70554
70555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70556   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70557
70558   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70559   {
70560     try {
70561       delete arg1;
70562     } catch (std::out_of_range& e) {
70563       {
70564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70565       };
70566     } catch (std::exception& e) {
70567       {
70568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70569       };
70570     } catch (Dali::DaliException e) {
70571       {
70572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70573       };
70574     } catch (...) {
70575       {
70576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70577       };
70578     }
70579   }
70580
70581 }
70582
70583
70584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70585   void * jresult ;
70586   Dali::Toolkit::PushButton result;
70587
70588   {
70589     try {
70590       result = Dali::Toolkit::PushButton::New();
70591     } catch (std::out_of_range& e) {
70592       {
70593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70594       };
70595     } catch (std::exception& e) {
70596       {
70597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70598       };
70599     } catch (Dali::DaliException e) {
70600       {
70601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70602       };
70603     } catch (...) {
70604       {
70605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70606       };
70607     }
70608   }
70609
70610   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70611   return jresult;
70612 }
70613
70614
70615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70616   void * jresult ;
70617   Dali::BaseHandle arg1 ;
70618   Dali::BaseHandle *argp1 ;
70619   Dali::Toolkit::PushButton result;
70620
70621   argp1 = (Dali::BaseHandle *)jarg1;
70622   if (!argp1) {
70623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70624     return 0;
70625   }
70626   arg1 = *argp1;
70627   {
70628     try {
70629       result = Dali::Toolkit::PushButton::DownCast(arg1);
70630     } catch (std::out_of_range& e) {
70631       {
70632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70633       };
70634     } catch (std::exception& e) {
70635       {
70636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70637       };
70638     } catch (Dali::DaliException e) {
70639       {
70640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70641       };
70642     } catch (...) {
70643       {
70644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70645       };
70646     }
70647   }
70648
70649   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70650   return jresult;
70651 }
70652
70653
70654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70655   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70656   Dali::Image arg2 ;
70657   Dali::Image *argp2 ;
70658
70659   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70660   argp2 = (Dali::Image *)jarg2;
70661   if (!argp2) {
70662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70663     return ;
70664   }
70665   arg2 = *argp2;
70666   {
70667     try {
70668       (arg1)->SetButtonImage(arg2);
70669     } catch (std::out_of_range& e) {
70670       {
70671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70672       };
70673     } catch (std::exception& e) {
70674       {
70675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70676       };
70677     } catch (Dali::DaliException e) {
70678       {
70679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70680       };
70681     } catch (...) {
70682       {
70683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70684       };
70685     }
70686   }
70687
70688 }
70689
70690
70691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70692   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70693   Dali::Actor arg2 ;
70694   Dali::Actor *argp2 ;
70695
70696   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70697   argp2 = (Dali::Actor *)jarg2;
70698   if (!argp2) {
70699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70700     return ;
70701   }
70702   arg2 = *argp2;
70703   {
70704     try {
70705       (arg1)->SetButtonImage(arg2);
70706     } catch (std::out_of_range& e) {
70707       {
70708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70709       };
70710     } catch (std::exception& e) {
70711       {
70712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70713       };
70714     } catch (Dali::DaliException e) {
70715       {
70716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70717       };
70718     } catch (...) {
70719       {
70720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70721       };
70722     }
70723   }
70724
70725 }
70726
70727
70728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70729   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70730   Dali::Actor arg2 ;
70731   Dali::Actor *argp2 ;
70732
70733   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70734   argp2 = (Dali::Actor *)jarg2;
70735   if (!argp2) {
70736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70737     return ;
70738   }
70739   arg2 = *argp2;
70740   {
70741     try {
70742       (arg1)->SetBackgroundImage(arg2);
70743     } catch (std::out_of_range& e) {
70744       {
70745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70746       };
70747     } catch (std::exception& e) {
70748       {
70749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70750       };
70751     } catch (Dali::DaliException e) {
70752       {
70753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70754       };
70755     } catch (...) {
70756       {
70757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70758       };
70759     }
70760   }
70761
70762 }
70763
70764
70765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70766   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70767   Dali::Image arg2 ;
70768   Dali::Image *argp2 ;
70769
70770   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70771   argp2 = (Dali::Image *)jarg2;
70772   if (!argp2) {
70773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70774     return ;
70775   }
70776   arg2 = *argp2;
70777   {
70778     try {
70779       (arg1)->SetSelectedImage(arg2);
70780     } catch (std::out_of_range& e) {
70781       {
70782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70783       };
70784     } catch (std::exception& e) {
70785       {
70786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70787       };
70788     } catch (Dali::DaliException e) {
70789       {
70790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70791       };
70792     } catch (...) {
70793       {
70794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70795       };
70796     }
70797   }
70798
70799 }
70800
70801
70802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70803   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70804   Dali::Actor arg2 ;
70805   Dali::Actor *argp2 ;
70806
70807   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70808   argp2 = (Dali::Actor *)jarg2;
70809   if (!argp2) {
70810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70811     return ;
70812   }
70813   arg2 = *argp2;
70814   {
70815     try {
70816       (arg1)->SetSelectedImage(arg2);
70817     } catch (std::out_of_range& e) {
70818       {
70819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70820       };
70821     } catch (std::exception& e) {
70822       {
70823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70824       };
70825     } catch (Dali::DaliException e) {
70826       {
70827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70828       };
70829     } catch (...) {
70830       {
70831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70832       };
70833     }
70834   }
70835
70836 }
70837
70838
70839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70840   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70841   Dali::Actor arg2 ;
70842   Dali::Actor *argp2 ;
70843
70844   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70845   argp2 = (Dali::Actor *)jarg2;
70846   if (!argp2) {
70847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70848     return ;
70849   }
70850   arg2 = *argp2;
70851   {
70852     try {
70853       (arg1)->SetSelectedBackgroundImage(arg2);
70854     } catch (std::out_of_range& e) {
70855       {
70856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70857       };
70858     } catch (std::exception& e) {
70859       {
70860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70861       };
70862     } catch (Dali::DaliException e) {
70863       {
70864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70865       };
70866     } catch (...) {
70867       {
70868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70869       };
70870     }
70871   }
70872
70873 }
70874
70875
70876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70877   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70878   Dali::Actor arg2 ;
70879   Dali::Actor *argp2 ;
70880
70881   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70882   argp2 = (Dali::Actor *)jarg2;
70883   if (!argp2) {
70884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70885     return ;
70886   }
70887   arg2 = *argp2;
70888   {
70889     try {
70890       (arg1)->SetDisabledBackgroundImage(arg2);
70891     } catch (std::out_of_range& e) {
70892       {
70893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70894       };
70895     } catch (std::exception& e) {
70896       {
70897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70898       };
70899     } catch (Dali::DaliException e) {
70900       {
70901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70902       };
70903     } catch (...) {
70904       {
70905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70906       };
70907     }
70908   }
70909
70910 }
70911
70912
70913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70914   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70915   Dali::Actor arg2 ;
70916   Dali::Actor *argp2 ;
70917
70918   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70919   argp2 = (Dali::Actor *)jarg2;
70920   if (!argp2) {
70921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70922     return ;
70923   }
70924   arg2 = *argp2;
70925   {
70926     try {
70927       (arg1)->SetDisabledImage(arg2);
70928     } catch (std::out_of_range& e) {
70929       {
70930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70931       };
70932     } catch (std::exception& e) {
70933       {
70934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70935       };
70936     } catch (Dali::DaliException e) {
70937       {
70938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70939       };
70940     } catch (...) {
70941       {
70942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70943       };
70944     }
70945   }
70946
70947 }
70948
70949
70950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70951   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70952   Dali::Actor arg2 ;
70953   Dali::Actor *argp2 ;
70954
70955   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70956   argp2 = (Dali::Actor *)jarg2;
70957   if (!argp2) {
70958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70959     return ;
70960   }
70961   arg2 = *argp2;
70962   {
70963     try {
70964       (arg1)->SetDisabledSelectedImage(arg2);
70965     } catch (std::out_of_range& e) {
70966       {
70967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70968       };
70969     } catch (std::exception& e) {
70970       {
70971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70972       };
70973     } catch (Dali::DaliException e) {
70974       {
70975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70976       };
70977     } catch (...) {
70978       {
70979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70980       };
70981     }
70982   }
70983
70984 }
70985
70986
70987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70988   void * jresult ;
70989   Dali::Toolkit::RadioButton *result = 0 ;
70990
70991   {
70992     try {
70993       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70994     } catch (std::out_of_range& e) {
70995       {
70996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70997       };
70998     } catch (std::exception& e) {
70999       {
71000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71001       };
71002     } catch (Dali::DaliException e) {
71003       {
71004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71005       };
71006     } catch (...) {
71007       {
71008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71009       };
71010     }
71011   }
71012
71013   jresult = (void *)result;
71014   return jresult;
71015 }
71016
71017
71018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71019   void * jresult ;
71020   Dali::Toolkit::RadioButton *arg1 = 0 ;
71021   Dali::Toolkit::RadioButton *result = 0 ;
71022
71023   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71024   if (!arg1) {
71025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71026     return 0;
71027   }
71028   {
71029     try {
71030       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71031     } catch (std::out_of_range& e) {
71032       {
71033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71034       };
71035     } catch (std::exception& e) {
71036       {
71037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71038       };
71039     } catch (Dali::DaliException e) {
71040       {
71041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71042       };
71043     } catch (...) {
71044       {
71045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71046       };
71047     }
71048   }
71049
71050   jresult = (void *)result;
71051   return jresult;
71052 }
71053
71054
71055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71056   void * jresult ;
71057   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71058   Dali::Toolkit::RadioButton *arg2 = 0 ;
71059   Dali::Toolkit::RadioButton *result = 0 ;
71060
71061   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71062   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71063   if (!arg2) {
71064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71065     return 0;
71066   }
71067   {
71068     try {
71069       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71070     } catch (std::out_of_range& e) {
71071       {
71072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71073       };
71074     } catch (std::exception& e) {
71075       {
71076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71077       };
71078     } catch (Dali::DaliException e) {
71079       {
71080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71081       };
71082     } catch (...) {
71083       {
71084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71085       };
71086     }
71087   }
71088
71089   jresult = (void *)result;
71090   return jresult;
71091 }
71092
71093
71094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71095   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71096
71097   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71098   {
71099     try {
71100       delete arg1;
71101     } catch (std::out_of_range& e) {
71102       {
71103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71104       };
71105     } catch (std::exception& e) {
71106       {
71107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71108       };
71109     } catch (Dali::DaliException e) {
71110       {
71111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71112       };
71113     } catch (...) {
71114       {
71115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71116       };
71117     }
71118   }
71119
71120 }
71121
71122
71123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71124   void * jresult ;
71125   Dali::Toolkit::RadioButton result;
71126
71127   {
71128     try {
71129       result = Dali::Toolkit::RadioButton::New();
71130     } catch (std::out_of_range& e) {
71131       {
71132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71133       };
71134     } catch (std::exception& e) {
71135       {
71136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71137       };
71138     } catch (Dali::DaliException e) {
71139       {
71140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71141       };
71142     } catch (...) {
71143       {
71144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71145       };
71146     }
71147   }
71148
71149   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71150   return jresult;
71151 }
71152
71153
71154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71155   void * jresult ;
71156   std::string *arg1 = 0 ;
71157   Dali::Toolkit::RadioButton result;
71158
71159   if (!jarg1) {
71160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71161     return 0;
71162   }
71163   std::string arg1_str(jarg1);
71164   arg1 = &arg1_str;
71165   {
71166     try {
71167       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71168     } catch (std::out_of_range& e) {
71169       {
71170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71171       };
71172     } catch (std::exception& e) {
71173       {
71174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71175       };
71176     } catch (Dali::DaliException e) {
71177       {
71178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71179       };
71180     } catch (...) {
71181       {
71182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71183       };
71184     }
71185   }
71186
71187   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71188
71189   //argout typemap for const std::string&
71190
71191   return jresult;
71192 }
71193
71194
71195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71196   void * jresult ;
71197   Dali::BaseHandle arg1 ;
71198   Dali::BaseHandle *argp1 ;
71199   Dali::Toolkit::RadioButton result;
71200
71201   argp1 = (Dali::BaseHandle *)jarg1;
71202   if (!argp1) {
71203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71204     return 0;
71205   }
71206   arg1 = *argp1;
71207   {
71208     try {
71209       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71210     } catch (std::out_of_range& e) {
71211       {
71212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71213       };
71214     } catch (std::exception& e) {
71215       {
71216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71217       };
71218     } catch (Dali::DaliException e) {
71219       {
71220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71221       };
71222     } catch (...) {
71223       {
71224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71225       };
71226     }
71227   }
71228
71229   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71230   return jresult;
71231 }
71232
71233
71234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71235   int jresult ;
71236   int result;
71237
71238   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71239   jresult = (int)result;
71240   return jresult;
71241 }
71242
71243
71244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71245   int jresult ;
71246   int result;
71247
71248   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71249   jresult = (int)result;
71250   return jresult;
71251 }
71252
71253
71254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71255   int jresult ;
71256   int result;
71257
71258   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71259   jresult = (int)result;
71260   return jresult;
71261 }
71262
71263
71264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71265   int jresult ;
71266   int result;
71267
71268   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71269   jresult = (int)result;
71270   return jresult;
71271 }
71272
71273
71274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71275   int jresult ;
71276   int result;
71277
71278   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71279   jresult = (int)result;
71280   return jresult;
71281 }
71282
71283
71284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71285   int jresult ;
71286   int result;
71287
71288   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71289   jresult = (int)result;
71290   return jresult;
71291 }
71292
71293
71294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71295   void * jresult ;
71296   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71297
71298   {
71299     try {
71300       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71301     } catch (std::out_of_range& e) {
71302       {
71303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71304       };
71305     } catch (std::exception& e) {
71306       {
71307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71308       };
71309     } catch (Dali::DaliException e) {
71310       {
71311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71312       };
71313     } catch (...) {
71314       {
71315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71316       };
71317     }
71318   }
71319
71320   jresult = (void *)result;
71321   return jresult;
71322 }
71323
71324
71325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71326   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71327
71328   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71329   {
71330     try {
71331       delete arg1;
71332     } catch (std::out_of_range& e) {
71333       {
71334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71335       };
71336     } catch (std::exception& e) {
71337       {
71338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71339       };
71340     } catch (Dali::DaliException e) {
71341       {
71342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71343       };
71344     } catch (...) {
71345       {
71346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71347       };
71348     }
71349   }
71350
71351 }
71352
71353
71354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71355   int jresult ;
71356   int result;
71357
71358   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71359   jresult = (int)result;
71360   return jresult;
71361 }
71362
71363
71364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71365   int jresult ;
71366   int result;
71367
71368   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71369   jresult = (int)result;
71370   return jresult;
71371 }
71372
71373
71374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71375   int jresult ;
71376   int result;
71377
71378   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71379   jresult = (int)result;
71380   return jresult;
71381 }
71382
71383
71384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71385   void * jresult ;
71386   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71387
71388   {
71389     try {
71390       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71391     } catch (std::out_of_range& e) {
71392       {
71393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71394       };
71395     } catch (std::exception& e) {
71396       {
71397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71398       };
71399     } catch (Dali::DaliException e) {
71400       {
71401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71402       };
71403     } catch (...) {
71404       {
71405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71406       };
71407     }
71408   }
71409
71410   jresult = (void *)result;
71411   return jresult;
71412 }
71413
71414
71415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71416   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71417
71418   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71419   {
71420     try {
71421       delete arg1;
71422     } catch (std::out_of_range& e) {
71423       {
71424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71425       };
71426     } catch (std::exception& e) {
71427       {
71428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71429       };
71430     } catch (Dali::DaliException e) {
71431       {
71432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71433       };
71434     } catch (...) {
71435       {
71436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71437       };
71438     }
71439   }
71440
71441 }
71442
71443
71444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71445   void * jresult ;
71446   Dali::Toolkit::FlexContainer *result = 0 ;
71447
71448   {
71449     try {
71450       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71451     } catch (std::out_of_range& e) {
71452       {
71453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71454       };
71455     } catch (std::exception& e) {
71456       {
71457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71458       };
71459     } catch (Dali::DaliException e) {
71460       {
71461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71462       };
71463     } catch (...) {
71464       {
71465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71466       };
71467     }
71468   }
71469
71470   jresult = (void *)result;
71471   return jresult;
71472 }
71473
71474
71475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71476   void * jresult ;
71477   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71478   Dali::Toolkit::FlexContainer *result = 0 ;
71479
71480   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71481   if (!arg1) {
71482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71483     return 0;
71484   }
71485   {
71486     try {
71487       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71488     } catch (std::out_of_range& e) {
71489       {
71490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71491       };
71492     } catch (std::exception& e) {
71493       {
71494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71495       };
71496     } catch (Dali::DaliException e) {
71497       {
71498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71499       };
71500     } catch (...) {
71501       {
71502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71503       };
71504     }
71505   }
71506
71507   jresult = (void *)result;
71508   return jresult;
71509 }
71510
71511
71512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71513   void * jresult ;
71514   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71515   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71516   Dali::Toolkit::FlexContainer *result = 0 ;
71517
71518   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71519   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71520   if (!arg2) {
71521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71522     return 0;
71523   }
71524   {
71525     try {
71526       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71527     } catch (std::out_of_range& e) {
71528       {
71529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71530       };
71531     } catch (std::exception& e) {
71532       {
71533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71534       };
71535     } catch (Dali::DaliException e) {
71536       {
71537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71538       };
71539     } catch (...) {
71540       {
71541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71542       };
71543     }
71544   }
71545
71546   jresult = (void *)result;
71547   return jresult;
71548 }
71549
71550
71551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71552   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71553
71554   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71555   {
71556     try {
71557       delete arg1;
71558     } catch (std::out_of_range& e) {
71559       {
71560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71561       };
71562     } catch (std::exception& e) {
71563       {
71564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71565       };
71566     } catch (Dali::DaliException e) {
71567       {
71568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71569       };
71570     } catch (...) {
71571       {
71572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71573       };
71574     }
71575   }
71576
71577 }
71578
71579
71580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71581   void * jresult ;
71582   Dali::Toolkit::FlexContainer result;
71583
71584   {
71585     try {
71586       result = Dali::Toolkit::FlexContainer::New();
71587     } catch (std::out_of_range& e) {
71588       {
71589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71590       };
71591     } catch (std::exception& e) {
71592       {
71593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71594       };
71595     } catch (Dali::DaliException e) {
71596       {
71597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71598       };
71599     } catch (...) {
71600       {
71601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71602       };
71603     }
71604   }
71605
71606   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71607   return jresult;
71608 }
71609
71610
71611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71612   void * jresult ;
71613   Dali::BaseHandle arg1 ;
71614   Dali::BaseHandle *argp1 ;
71615   Dali::Toolkit::FlexContainer result;
71616
71617   argp1 = (Dali::BaseHandle *)jarg1;
71618   if (!argp1) {
71619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71620     return 0;
71621   }
71622   arg1 = *argp1;
71623   {
71624     try {
71625       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71626     } catch (std::out_of_range& e) {
71627       {
71628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71629       };
71630     } catch (std::exception& e) {
71631       {
71632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71633       };
71634     } catch (Dali::DaliException e) {
71635       {
71636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71637       };
71638     } catch (...) {
71639       {
71640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71641       };
71642     }
71643   }
71644
71645   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71646   return jresult;
71647 }
71648
71649
71650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71651   int jresult ;
71652   int result;
71653
71654   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71655   jresult = (int)result;
71656   return jresult;
71657 }
71658
71659
71660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71661   int jresult ;
71662   int result;
71663
71664   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71665   jresult = (int)result;
71666   return jresult;
71667 }
71668
71669
71670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71671   int jresult ;
71672   int result;
71673
71674   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71675   jresult = (int)result;
71676   return jresult;
71677 }
71678
71679
71680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71681   int jresult ;
71682   int result;
71683
71684   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71685   jresult = (int)result;
71686   return jresult;
71687 }
71688
71689
71690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71691   void * jresult ;
71692   Dali::Toolkit::ImageView::Property *result = 0 ;
71693
71694   {
71695     try {
71696       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71697     } catch (std::out_of_range& e) {
71698       {
71699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71700       };
71701     } catch (std::exception& e) {
71702       {
71703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71704       };
71705     } catch (Dali::DaliException e) {
71706       {
71707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71708       };
71709     } catch (...) {
71710       {
71711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71712       };
71713     }
71714   }
71715
71716   jresult = (void *)result;
71717   return jresult;
71718 }
71719
71720
71721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71722   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71723
71724   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71725   {
71726     try {
71727       delete arg1;
71728     } catch (std::out_of_range& e) {
71729       {
71730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71731       };
71732     } catch (std::exception& e) {
71733       {
71734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71735       };
71736     } catch (Dali::DaliException e) {
71737       {
71738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71739       };
71740     } catch (...) {
71741       {
71742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71743       };
71744     }
71745   }
71746
71747 }
71748
71749
71750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71751   void * jresult ;
71752   Dali::Toolkit::ImageView *result = 0 ;
71753
71754   {
71755     try {
71756       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71757     } catch (std::out_of_range& e) {
71758       {
71759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71760       };
71761     } catch (std::exception& e) {
71762       {
71763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71764       };
71765     } catch (Dali::DaliException e) {
71766       {
71767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71768       };
71769     } catch (...) {
71770       {
71771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71772       };
71773     }
71774   }
71775
71776   jresult = (void *)result;
71777   return jresult;
71778 }
71779
71780
71781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71782   void * jresult ;
71783   Dali::Toolkit::ImageView result;
71784
71785   {
71786     try {
71787       result = Dali::Toolkit::ImageView::New();
71788     } catch (std::out_of_range& e) {
71789       {
71790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71791       };
71792     } catch (std::exception& e) {
71793       {
71794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71795       };
71796     } catch (Dali::DaliException e) {
71797       {
71798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71799       };
71800     } catch (...) {
71801       {
71802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71803       };
71804     }
71805   }
71806
71807   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71808   return jresult;
71809 }
71810
71811
71812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71813   void * jresult ;
71814   Dali::Image arg1 ;
71815   Dali::Image *argp1 ;
71816   Dali::Toolkit::ImageView result;
71817
71818   argp1 = (Dali::Image *)jarg1;
71819   if (!argp1) {
71820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71821     return 0;
71822   }
71823   arg1 = *argp1;
71824   {
71825     try {
71826       result = Dali::Toolkit::ImageView::New(arg1);
71827     } catch (std::out_of_range& e) {
71828       {
71829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71830       };
71831     } catch (std::exception& e) {
71832       {
71833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71834       };
71835     } catch (Dali::DaliException e) {
71836       {
71837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71838       };
71839     } catch (...) {
71840       {
71841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71842       };
71843     }
71844   }
71845
71846   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71847   return jresult;
71848 }
71849
71850
71851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71852   void * jresult ;
71853   std::string *arg1 = 0 ;
71854   Dali::Toolkit::ImageView result;
71855
71856   if (!jarg1) {
71857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71858     return 0;
71859   }
71860   std::string arg1_str(jarg1);
71861   arg1 = &arg1_str;
71862   {
71863     try {
71864       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71865     } catch (std::out_of_range& e) {
71866       {
71867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71868       };
71869     } catch (std::exception& e) {
71870       {
71871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71872       };
71873     } catch (Dali::DaliException e) {
71874       {
71875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71876       };
71877     } catch (...) {
71878       {
71879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71880       };
71881     }
71882   }
71883
71884   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71885
71886   //argout typemap for const std::string&
71887
71888   return jresult;
71889 }
71890
71891
71892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71893   void * jresult ;
71894   std::string *arg1 = 0 ;
71895   Dali::ImageDimensions arg2 ;
71896   Dali::ImageDimensions *argp2 ;
71897   Dali::Toolkit::ImageView result;
71898
71899   if (!jarg1) {
71900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71901     return 0;
71902   }
71903   std::string arg1_str(jarg1);
71904   arg1 = &arg1_str;
71905   argp2 = (Dali::ImageDimensions *)jarg2;
71906   if (!argp2) {
71907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71908     return 0;
71909   }
71910   arg2 = *argp2;
71911   {
71912     try {
71913       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71914     } catch (std::out_of_range& e) {
71915       {
71916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71917       };
71918     } catch (std::exception& e) {
71919       {
71920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71921       };
71922     } catch (Dali::DaliException e) {
71923       {
71924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71925       };
71926     } catch (...) {
71927       {
71928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71929       };
71930     }
71931   }
71932
71933   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71934
71935   //argout typemap for const std::string&
71936
71937   return jresult;
71938 }
71939
71940
71941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71942   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71943
71944   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71945   {
71946     try {
71947       delete arg1;
71948     } catch (std::out_of_range& e) {
71949       {
71950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71951       };
71952     } catch (std::exception& e) {
71953       {
71954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71955       };
71956     } catch (Dali::DaliException e) {
71957       {
71958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71959       };
71960     } catch (...) {
71961       {
71962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71963       };
71964     }
71965   }
71966
71967 }
71968
71969
71970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71971   void * jresult ;
71972   Dali::Toolkit::ImageView *arg1 = 0 ;
71973   Dali::Toolkit::ImageView *result = 0 ;
71974
71975   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71976   if (!arg1) {
71977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71978     return 0;
71979   }
71980   {
71981     try {
71982       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71983     } catch (std::out_of_range& e) {
71984       {
71985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71986       };
71987     } catch (std::exception& e) {
71988       {
71989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71990       };
71991     } catch (Dali::DaliException e) {
71992       {
71993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71994       };
71995     } catch (...) {
71996       {
71997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71998       };
71999     }
72000   }
72001
72002   jresult = (void *)result;
72003   return jresult;
72004 }
72005
72006
72007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72008   void * jresult ;
72009   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72010   Dali::Toolkit::ImageView *arg2 = 0 ;
72011   Dali::Toolkit::ImageView *result = 0 ;
72012
72013   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72014   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72015   if (!arg2) {
72016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72017     return 0;
72018   }
72019   {
72020     try {
72021       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72022     } catch (std::out_of_range& e) {
72023       {
72024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72025       };
72026     } catch (std::exception& e) {
72027       {
72028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72029       };
72030     } catch (Dali::DaliException e) {
72031       {
72032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72033       };
72034     } catch (...) {
72035       {
72036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72037       };
72038     }
72039   }
72040
72041   jresult = (void *)result;
72042   return jresult;
72043 }
72044
72045
72046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72047   void * jresult ;
72048   Dali::BaseHandle arg1 ;
72049   Dali::BaseHandle *argp1 ;
72050   Dali::Toolkit::ImageView result;
72051
72052   argp1 = (Dali::BaseHandle *)jarg1;
72053   if (!argp1) {
72054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72055     return 0;
72056   }
72057   arg1 = *argp1;
72058   {
72059     try {
72060       result = Dali::Toolkit::ImageView::DownCast(arg1);
72061     } catch (std::out_of_range& e) {
72062       {
72063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72064       };
72065     } catch (std::exception& e) {
72066       {
72067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72068       };
72069     } catch (Dali::DaliException e) {
72070       {
72071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72072       };
72073     } catch (...) {
72074       {
72075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72076       };
72077     }
72078   }
72079
72080   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72081   return jresult;
72082 }
72083
72084
72085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72086   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72087   Dali::Image arg2 ;
72088   Dali::Image *argp2 ;
72089
72090   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72091   argp2 = (Dali::Image *)jarg2;
72092   if (!argp2) {
72093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72094     return ;
72095   }
72096   arg2 = *argp2;
72097   {
72098     try {
72099       (arg1)->SetImage(arg2);
72100     } catch (std::out_of_range& e) {
72101       {
72102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72103       };
72104     } catch (std::exception& e) {
72105       {
72106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72107       };
72108     } catch (Dali::DaliException e) {
72109       {
72110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72111       };
72112     } catch (...) {
72113       {
72114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72115       };
72116     }
72117   }
72118
72119 }
72120
72121
72122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72123   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72124   std::string *arg2 = 0 ;
72125
72126   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72127   if (!jarg2) {
72128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72129     return ;
72130   }
72131   std::string arg2_str(jarg2);
72132   arg2 = &arg2_str;
72133   {
72134     try {
72135       (arg1)->SetImage((std::string const &)*arg2);
72136     } catch (std::out_of_range& e) {
72137       {
72138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72139       };
72140     } catch (std::exception& e) {
72141       {
72142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72143       };
72144     } catch (Dali::DaliException e) {
72145       {
72146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72147       };
72148     } catch (...) {
72149       {
72150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72151       };
72152     }
72153   }
72154
72155
72156   //argout typemap for const std::string&
72157
72158 }
72159
72160
72161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72162   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72163   std::string *arg2 = 0 ;
72164   Dali::ImageDimensions arg3 ;
72165   Dali::ImageDimensions *argp3 ;
72166
72167   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72168   if (!jarg2) {
72169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72170     return ;
72171   }
72172   std::string arg2_str(jarg2);
72173   arg2 = &arg2_str;
72174   argp3 = (Dali::ImageDimensions *)jarg3;
72175   if (!argp3) {
72176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72177     return ;
72178   }
72179   arg3 = *argp3;
72180   {
72181     try {
72182       (arg1)->SetImage((std::string const &)*arg2,arg3);
72183     } catch (std::out_of_range& e) {
72184       {
72185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72186       };
72187     } catch (std::exception& e) {
72188       {
72189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72190       };
72191     } catch (Dali::DaliException e) {
72192       {
72193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72194       };
72195     } catch (...) {
72196       {
72197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72198       };
72199     }
72200   }
72201
72202
72203   //argout typemap for const std::string&
72204
72205 }
72206
72207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72208   void * jresult ;
72209   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72210   Dali::Image result;
72211
72212   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72213   {
72214     try {
72215       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72216     } catch (std::out_of_range& e) {
72217       {
72218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72219       };
72220     } catch (std::exception& e) {
72221       {
72222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72223       };
72224     } catch (Dali::DaliException e) {
72225       {
72226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72227       };
72228     } catch (...) {
72229       {
72230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72231       };
72232     }
72233   }
72234
72235   jresult = new Dali::Image((const Dali::Image &)result);
72236   return jresult;
72237 }
72238
72239
72240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72241   int jresult ;
72242   int result;
72243
72244   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72245   jresult = (int)result;
72246   return jresult;
72247 }
72248
72249
72250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72251   int jresult ;
72252   int result;
72253
72254   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72255   jresult = (int)result;
72256   return jresult;
72257 }
72258
72259
72260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72261   int jresult ;
72262   int result;
72263
72264   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72265   jresult = (int)result;
72266   return jresult;
72267 }
72268
72269
72270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72271   int jresult ;
72272   int result;
72273
72274   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72275   jresult = (int)result;
72276   return jresult;
72277 }
72278
72279
72280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72281   int jresult ;
72282   int result;
72283
72284   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72285   jresult = (int)result;
72286   return jresult;
72287 }
72288
72289
72290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72291   int jresult ;
72292   int result;
72293
72294   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72295   jresult = (int)result;
72296   return jresult;
72297 }
72298
72299
72300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72301   int jresult ;
72302   int result;
72303
72304   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72305   jresult = (int)result;
72306   return jresult;
72307 }
72308
72309
72310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72311   int jresult ;
72312   int result;
72313
72314   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72315   jresult = (int)result;
72316   return jresult;
72317 }
72318
72319
72320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72321   void * jresult ;
72322   Dali::Toolkit::Model3dView::Property *result = 0 ;
72323
72324   {
72325     try {
72326       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72327     } catch (std::out_of_range& e) {
72328       {
72329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72330       };
72331     } catch (std::exception& e) {
72332       {
72333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72334       };
72335     } catch (Dali::DaliException e) {
72336       {
72337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72338       };
72339     } catch (...) {
72340       {
72341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72342       };
72343     }
72344   }
72345
72346   jresult = (void *)result;
72347   return jresult;
72348 }
72349
72350
72351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72352   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72353
72354   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72355   {
72356     try {
72357       delete arg1;
72358     } catch (std::out_of_range& e) {
72359       {
72360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72361       };
72362     } catch (std::exception& e) {
72363       {
72364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72365       };
72366     } catch (Dali::DaliException e) {
72367       {
72368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72369       };
72370     } catch (...) {
72371       {
72372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72373       };
72374     }
72375   }
72376
72377 }
72378
72379
72380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72381   void * jresult ;
72382   Dali::Toolkit::Model3dView result;
72383
72384   {
72385     try {
72386       result = Dali::Toolkit::Model3dView::New();
72387     } catch (std::out_of_range& e) {
72388       {
72389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72390       };
72391     } catch (std::exception& e) {
72392       {
72393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72394       };
72395     } catch (Dali::DaliException e) {
72396       {
72397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72398       };
72399     } catch (...) {
72400       {
72401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72402       };
72403     }
72404   }
72405
72406   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72407   return jresult;
72408 }
72409
72410
72411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72412   void * jresult ;
72413   std::string *arg1 = 0 ;
72414   std::string *arg2 = 0 ;
72415   std::string *arg3 = 0 ;
72416   Dali::Toolkit::Model3dView result;
72417
72418   if (!jarg1) {
72419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72420     return 0;
72421   }
72422   std::string arg1_str(jarg1);
72423   arg1 = &arg1_str;
72424   if (!jarg2) {
72425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72426     return 0;
72427   }
72428   std::string arg2_str(jarg2);
72429   arg2 = &arg2_str;
72430   if (!jarg3) {
72431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72432     return 0;
72433   }
72434   std::string arg3_str(jarg3);
72435   arg3 = &arg3_str;
72436   {
72437     try {
72438       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72439     } catch (std::out_of_range& e) {
72440       {
72441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72442       };
72443     } catch (std::exception& e) {
72444       {
72445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72446       };
72447     } catch (Dali::DaliException e) {
72448       {
72449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72450       };
72451     } catch (...) {
72452       {
72453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72454       };
72455     }
72456   }
72457
72458   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72459
72460   //argout typemap for const std::string&
72461
72462
72463   //argout typemap for const std::string&
72464
72465
72466   //argout typemap for const std::string&
72467
72468   return jresult;
72469 }
72470
72471
72472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72473   void * jresult ;
72474   Dali::Toolkit::Model3dView *result = 0 ;
72475
72476   {
72477     try {
72478       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72479     } catch (std::out_of_range& e) {
72480       {
72481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72482       };
72483     } catch (std::exception& e) {
72484       {
72485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72486       };
72487     } catch (Dali::DaliException e) {
72488       {
72489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72490       };
72491     } catch (...) {
72492       {
72493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72494       };
72495     }
72496   }
72497
72498   jresult = (void *)result;
72499   return jresult;
72500 }
72501
72502
72503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72504   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72505
72506   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72507   {
72508     try {
72509       delete arg1;
72510     } catch (std::out_of_range& e) {
72511       {
72512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72513       };
72514     } catch (std::exception& e) {
72515       {
72516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72517       };
72518     } catch (Dali::DaliException e) {
72519       {
72520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72521       };
72522     } catch (...) {
72523       {
72524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72525       };
72526     }
72527   }
72528
72529 }
72530
72531
72532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72533   void * jresult ;
72534   Dali::Toolkit::Model3dView *arg1 = 0 ;
72535   Dali::Toolkit::Model3dView *result = 0 ;
72536
72537   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72538   if (!arg1) {
72539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72540     return 0;
72541   }
72542   {
72543     try {
72544       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72545     } catch (std::out_of_range& e) {
72546       {
72547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72548       };
72549     } catch (std::exception& e) {
72550       {
72551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72552       };
72553     } catch (Dali::DaliException e) {
72554       {
72555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72556       };
72557     } catch (...) {
72558       {
72559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72560       };
72561     }
72562   }
72563
72564   jresult = (void *)result;
72565   return jresult;
72566 }
72567
72568
72569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72570   void * jresult ;
72571   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72572   Dali::Toolkit::Model3dView *arg2 = 0 ;
72573   Dali::Toolkit::Model3dView *result = 0 ;
72574
72575   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72576   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72577   if (!arg2) {
72578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72579     return 0;
72580   }
72581   {
72582     try {
72583       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72584     } catch (std::out_of_range& e) {
72585       {
72586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72587       };
72588     } catch (std::exception& e) {
72589       {
72590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72591       };
72592     } catch (Dali::DaliException e) {
72593       {
72594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72595       };
72596     } catch (...) {
72597       {
72598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72599       };
72600     }
72601   }
72602
72603   jresult = (void *)result;
72604   return jresult;
72605 }
72606
72607
72608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72609   void * jresult ;
72610   Dali::BaseHandle arg1 ;
72611   Dali::BaseHandle *argp1 ;
72612   Dali::Toolkit::Model3dView result;
72613
72614   argp1 = (Dali::BaseHandle *)jarg1;
72615   if (!argp1) {
72616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72617     return 0;
72618   }
72619   arg1 = *argp1;
72620   {
72621     try {
72622       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72623     } catch (std::out_of_range& e) {
72624       {
72625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72626       };
72627     } catch (std::exception& e) {
72628       {
72629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72630       };
72631     } catch (Dali::DaliException e) {
72632       {
72633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72634       };
72635     } catch (...) {
72636       {
72637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72638       };
72639     }
72640   }
72641
72642   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72643   return jresult;
72644 }
72645
72646
72647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72648   int jresult ;
72649   int result;
72650
72651   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72652   jresult = (int)result;
72653   return jresult;
72654 }
72655
72656
72657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72658   int jresult ;
72659   int result;
72660
72661   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72662   jresult = (int)result;
72663   return jresult;
72664 }
72665
72666
72667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72668   int jresult ;
72669   int result;
72670
72671   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72672   jresult = (int)result;
72673   return jresult;
72674 }
72675
72676
72677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72678   int jresult ;
72679   int result;
72680
72681   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72682   jresult = (int)result;
72683   return jresult;
72684 }
72685
72686
72687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72688   int jresult ;
72689   int result;
72690
72691   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72692   jresult = (int)result;
72693   return jresult;
72694 }
72695
72696
72697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72698   int jresult ;
72699   int result;
72700
72701   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72702   jresult = (int)result;
72703   return jresult;
72704 }
72705
72706
72707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72708   int jresult ;
72709   int result;
72710
72711   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72712   jresult = (int)result;
72713   return jresult;
72714 }
72715
72716
72717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72718   int jresult ;
72719   int result;
72720
72721   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72722   jresult = (int)result;
72723   return jresult;
72724 }
72725
72726
72727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72728   int jresult ;
72729   int result;
72730
72731   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72732   jresult = (int)result;
72733   return jresult;
72734 }
72735
72736
72737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72738   void * jresult ;
72739   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72740
72741   {
72742     try {
72743       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72744     } catch (std::out_of_range& e) {
72745       {
72746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72747       };
72748     } catch (std::exception& e) {
72749       {
72750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72751       };
72752     } catch (Dali::DaliException e) {
72753       {
72754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72755       };
72756     } catch (...) {
72757       {
72758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72759       };
72760     }
72761   }
72762
72763   jresult = (void *)result;
72764   return jresult;
72765 }
72766
72767
72768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72769   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72770
72771   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72772   {
72773     try {
72774       delete arg1;
72775     } catch (std::out_of_range& e) {
72776       {
72777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72778       };
72779     } catch (std::exception& e) {
72780       {
72781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72782       };
72783     } catch (Dali::DaliException e) {
72784       {
72785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72786       };
72787     } catch (...) {
72788       {
72789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72790       };
72791     }
72792   }
72793
72794 }
72795
72796
72797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72798   void * jresult ;
72799   Dali::Toolkit::ScrollBar *result = 0 ;
72800
72801   {
72802     try {
72803       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72804     } catch (std::out_of_range& e) {
72805       {
72806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72807       };
72808     } catch (std::exception& e) {
72809       {
72810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72811       };
72812     } catch (Dali::DaliException e) {
72813       {
72814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72815       };
72816     } catch (...) {
72817       {
72818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72819       };
72820     }
72821   }
72822
72823   jresult = (void *)result;
72824   return jresult;
72825 }
72826
72827
72828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72829   void * jresult ;
72830   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72831   Dali::Toolkit::ScrollBar *result = 0 ;
72832
72833   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72834   if (!arg1) {
72835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72836     return 0;
72837   }
72838   {
72839     try {
72840       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72841     } catch (std::out_of_range& e) {
72842       {
72843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72844       };
72845     } catch (std::exception& e) {
72846       {
72847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72848       };
72849     } catch (Dali::DaliException e) {
72850       {
72851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72852       };
72853     } catch (...) {
72854       {
72855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72856       };
72857     }
72858   }
72859
72860   jresult = (void *)result;
72861   return jresult;
72862 }
72863
72864
72865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72866   void * jresult ;
72867   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72868   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72869   Dali::Toolkit::ScrollBar *result = 0 ;
72870
72871   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72872   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72873   if (!arg2) {
72874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72875     return 0;
72876   }
72877   {
72878     try {
72879       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72880     } catch (std::out_of_range& e) {
72881       {
72882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72883       };
72884     } catch (std::exception& e) {
72885       {
72886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72887       };
72888     } catch (Dali::DaliException e) {
72889       {
72890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72891       };
72892     } catch (...) {
72893       {
72894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72895       };
72896     }
72897   }
72898
72899   jresult = (void *)result;
72900   return jresult;
72901 }
72902
72903
72904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72905   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72906
72907   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72908   {
72909     try {
72910       delete arg1;
72911     } catch (std::out_of_range& e) {
72912       {
72913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72914       };
72915     } catch (std::exception& e) {
72916       {
72917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72918       };
72919     } catch (Dali::DaliException e) {
72920       {
72921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72922       };
72923     } catch (...) {
72924       {
72925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72926       };
72927     }
72928   }
72929
72930 }
72931
72932
72933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72934   void * jresult ;
72935   Dali::Toolkit::ScrollBar::Direction arg1 ;
72936   Dali::Toolkit::ScrollBar result;
72937
72938   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72939   {
72940     try {
72941       result = Dali::Toolkit::ScrollBar::New(arg1);
72942     } catch (std::out_of_range& e) {
72943       {
72944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72945       };
72946     } catch (std::exception& e) {
72947       {
72948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72949       };
72950     } catch (Dali::DaliException e) {
72951       {
72952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72953       };
72954     } catch (...) {
72955       {
72956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72957       };
72958     }
72959   }
72960
72961   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72962   return jresult;
72963 }
72964
72965
72966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72967   void * jresult ;
72968   Dali::Toolkit::ScrollBar result;
72969
72970   {
72971     try {
72972       result = Dali::Toolkit::ScrollBar::New();
72973     } catch (std::out_of_range& e) {
72974       {
72975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72976       };
72977     } catch (std::exception& e) {
72978       {
72979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72980       };
72981     } catch (Dali::DaliException e) {
72982       {
72983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72984       };
72985     } catch (...) {
72986       {
72987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72988       };
72989     }
72990   }
72991
72992   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72993   return jresult;
72994 }
72995
72996
72997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
72998   void * jresult ;
72999   Dali::BaseHandle arg1 ;
73000   Dali::BaseHandle *argp1 ;
73001   Dali::Toolkit::ScrollBar result;
73002
73003   argp1 = (Dali::BaseHandle *)jarg1;
73004   if (!argp1) {
73005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73006     return 0;
73007   }
73008   arg1 = *argp1;
73009   {
73010     try {
73011       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73012     } catch (std::out_of_range& e) {
73013       {
73014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73015       };
73016     } catch (std::exception& e) {
73017       {
73018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73019       };
73020     } catch (Dali::DaliException e) {
73021       {
73022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73023       };
73024     } catch (...) {
73025       {
73026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73027       };
73028     }
73029   }
73030
73031   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73032   return jresult;
73033 }
73034
73035
73036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73037   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73038   Dali::Handle arg2 ;
73039   Dali::Property::Index arg3 ;
73040   Dali::Property::Index arg4 ;
73041   Dali::Property::Index arg5 ;
73042   Dali::Property::Index arg6 ;
73043   Dali::Handle *argp2 ;
73044
73045   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73046   argp2 = (Dali::Handle *)jarg2;
73047   if (!argp2) {
73048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73049     return ;
73050   }
73051   arg2 = *argp2;
73052   arg3 = (Dali::Property::Index)jarg3;
73053   arg4 = (Dali::Property::Index)jarg4;
73054   arg5 = (Dali::Property::Index)jarg5;
73055   arg6 = (Dali::Property::Index)jarg6;
73056   {
73057     try {
73058       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73059     } catch (std::out_of_range& e) {
73060       {
73061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73062       };
73063     } catch (std::exception& e) {
73064       {
73065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73066       };
73067     } catch (Dali::DaliException e) {
73068       {
73069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73070       };
73071     } catch (...) {
73072       {
73073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73074       };
73075     }
73076   }
73077
73078 }
73079
73080
73081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73082   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73083   Dali::Actor arg2 ;
73084   Dali::Actor *argp2 ;
73085
73086   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73087   argp2 = (Dali::Actor *)jarg2;
73088   if (!argp2) {
73089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73090     return ;
73091   }
73092   arg2 = *argp2;
73093   {
73094     try {
73095       (arg1)->SetScrollIndicator(arg2);
73096     } catch (std::out_of_range& e) {
73097       {
73098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73099       };
73100     } catch (std::exception& e) {
73101       {
73102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73103       };
73104     } catch (Dali::DaliException e) {
73105       {
73106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73107       };
73108     } catch (...) {
73109       {
73110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73111       };
73112     }
73113   }
73114
73115 }
73116
73117
73118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73119   void * jresult ;
73120   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73121   Dali::Actor result;
73122
73123   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73124   {
73125     try {
73126       result = (arg1)->GetScrollIndicator();
73127     } catch (std::out_of_range& e) {
73128       {
73129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73130       };
73131     } catch (std::exception& e) {
73132       {
73133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73134       };
73135     } catch (Dali::DaliException e) {
73136       {
73137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73138       };
73139     } catch (...) {
73140       {
73141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73142       };
73143     }
73144   }
73145
73146   jresult = new Dali::Actor((const Dali::Actor &)result);
73147   return jresult;
73148 }
73149
73150
73151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73152   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73153   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73154
73155   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73156   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73157   if (!arg2) {
73158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73159     return ;
73160   }
73161   {
73162     try {
73163       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73164     } catch (std::out_of_range& e) {
73165       {
73166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73167       };
73168     } catch (std::exception& e) {
73169       {
73170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73171       };
73172     } catch (Dali::DaliException e) {
73173       {
73174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73175       };
73176     } catch (...) {
73177       {
73178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73179       };
73180     }
73181   }
73182
73183 }
73184
73185
73186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73187   void * jresult ;
73188   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73189
73190   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73191   {
73192     try {
73193       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()));
73194     } catch (std::out_of_range& e) {
73195       {
73196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73197       };
73198     } catch (std::exception& e) {
73199       {
73200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73201       };
73202     } catch (...) {
73203       {
73204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73205       };
73206     }
73207   }
73208   return jresult;
73209 }
73210
73211
73212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73213   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73214   Dali::Toolkit::ScrollBar::Direction arg2 ;
73215
73216   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73217   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73218   {
73219     try {
73220       (arg1)->SetScrollDirection(arg2);
73221     } catch (std::out_of_range& e) {
73222       {
73223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73224       };
73225     } catch (std::exception& e) {
73226       {
73227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73228       };
73229     } catch (Dali::DaliException e) {
73230       {
73231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73232       };
73233     } catch (...) {
73234       {
73235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73236       };
73237     }
73238   }
73239
73240 }
73241
73242
73243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73244   int jresult ;
73245   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73246   Dali::Toolkit::ScrollBar::Direction result;
73247
73248   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73249   {
73250     try {
73251       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73252     } catch (std::out_of_range& e) {
73253       {
73254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73255       };
73256     } catch (std::exception& e) {
73257       {
73258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73259       };
73260     } catch (Dali::DaliException e) {
73261       {
73262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73263       };
73264     } catch (...) {
73265       {
73266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73267       };
73268     }
73269   }
73270
73271   jresult = (int)result;
73272   return jresult;
73273 }
73274
73275
73276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73277   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73278   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73279
73280   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73281   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73282   {
73283     try {
73284       (arg1)->SetIndicatorHeightPolicy(arg2);
73285     } catch (std::out_of_range& e) {
73286       {
73287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73288       };
73289     } catch (std::exception& e) {
73290       {
73291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73292       };
73293     } catch (Dali::DaliException e) {
73294       {
73295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73296       };
73297     } catch (...) {
73298       {
73299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73300       };
73301     }
73302   }
73303
73304 }
73305
73306
73307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73308   int jresult ;
73309   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73310   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73311
73312   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73313   {
73314     try {
73315       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73316     } catch (std::out_of_range& e) {
73317       {
73318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73319       };
73320     } catch (std::exception& e) {
73321       {
73322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73323       };
73324     } catch (Dali::DaliException e) {
73325       {
73326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73327       };
73328     } catch (...) {
73329       {
73330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73331       };
73332     }
73333   }
73334
73335   jresult = (int)result;
73336   return jresult;
73337 }
73338
73339
73340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73341   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73342   float arg2 ;
73343
73344   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73345   arg2 = (float)jarg2;
73346   {
73347     try {
73348       (arg1)->SetIndicatorFixedHeight(arg2);
73349     } catch (std::out_of_range& e) {
73350       {
73351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73352       };
73353     } catch (std::exception& e) {
73354       {
73355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73356       };
73357     } catch (Dali::DaliException e) {
73358       {
73359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73360       };
73361     } catch (...) {
73362       {
73363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73364       };
73365     }
73366   }
73367
73368 }
73369
73370
73371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73372   float jresult ;
73373   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73374   float result;
73375
73376   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73377   {
73378     try {
73379       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73380     } catch (std::out_of_range& e) {
73381       {
73382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73383       };
73384     } catch (std::exception& e) {
73385       {
73386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73387       };
73388     } catch (Dali::DaliException e) {
73389       {
73390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73391       };
73392     } catch (...) {
73393       {
73394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73395       };
73396     }
73397   }
73398
73399   jresult = result;
73400   return jresult;
73401 }
73402
73403
73404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73405   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73406   float arg2 ;
73407
73408   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73409   arg2 = (float)jarg2;
73410   {
73411     try {
73412       (arg1)->SetIndicatorShowDuration(arg2);
73413     } catch (std::out_of_range& e) {
73414       {
73415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73416       };
73417     } catch (std::exception& e) {
73418       {
73419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73420       };
73421     } catch (Dali::DaliException e) {
73422       {
73423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73424       };
73425     } catch (...) {
73426       {
73427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73428       };
73429     }
73430   }
73431
73432 }
73433
73434
73435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73436   float jresult ;
73437   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73438   float result;
73439
73440   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73441   {
73442     try {
73443       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73444     } catch (std::out_of_range& e) {
73445       {
73446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73447       };
73448     } catch (std::exception& e) {
73449       {
73450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73451       };
73452     } catch (Dali::DaliException e) {
73453       {
73454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73455       };
73456     } catch (...) {
73457       {
73458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73459       };
73460     }
73461   }
73462
73463   jresult = result;
73464   return jresult;
73465 }
73466
73467
73468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73469   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73470   float arg2 ;
73471
73472   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73473   arg2 = (float)jarg2;
73474   {
73475     try {
73476       (arg1)->SetIndicatorHideDuration(arg2);
73477     } catch (std::out_of_range& e) {
73478       {
73479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73480       };
73481     } catch (std::exception& e) {
73482       {
73483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73484       };
73485     } catch (Dali::DaliException e) {
73486       {
73487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73488       };
73489     } catch (...) {
73490       {
73491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73492       };
73493     }
73494   }
73495
73496 }
73497
73498
73499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73500   float jresult ;
73501   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73502   float result;
73503
73504   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73505   {
73506     try {
73507       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73508     } catch (std::out_of_range& e) {
73509       {
73510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73511       };
73512     } catch (std::exception& e) {
73513       {
73514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73515       };
73516     } catch (Dali::DaliException e) {
73517       {
73518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73519       };
73520     } catch (...) {
73521       {
73522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73523       };
73524     }
73525   }
73526
73527   jresult = result;
73528   return jresult;
73529 }
73530
73531
73532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73533   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73534
73535   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73536   {
73537     try {
73538       (arg1)->ShowIndicator();
73539     } catch (std::out_of_range& e) {
73540       {
73541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73542       };
73543     } catch (std::exception& e) {
73544       {
73545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73546       };
73547     } catch (Dali::DaliException e) {
73548       {
73549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73550       };
73551     } catch (...) {
73552       {
73553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73554       };
73555     }
73556   }
73557
73558 }
73559
73560
73561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73562   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73563
73564   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73565   {
73566     try {
73567       (arg1)->HideIndicator();
73568     } catch (std::out_of_range& e) {
73569       {
73570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73571       };
73572     } catch (std::exception& e) {
73573       {
73574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73575       };
73576     } catch (Dali::DaliException e) {
73577       {
73578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73579       };
73580     } catch (...) {
73581       {
73582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73583       };
73584     }
73585   }
73586
73587 }
73588
73589
73590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73591   void * jresult ;
73592   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73593   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73594
73595   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73596   {
73597     try {
73598       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73599     } catch (std::out_of_range& e) {
73600       {
73601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73602       };
73603     } catch (std::exception& e) {
73604       {
73605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73606       };
73607     } catch (Dali::DaliException e) {
73608       {
73609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73610       };
73611     } catch (...) {
73612       {
73613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73614       };
73615     }
73616   }
73617
73618   jresult = (void *)result;
73619   return jresult;
73620 }
73621
73622
73623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73624   void * jresult ;
73625   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73626   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73627
73628   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73629   {
73630     try {
73631       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73632     } catch (std::out_of_range& e) {
73633       {
73634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73635       };
73636     } catch (std::exception& e) {
73637       {
73638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73639       };
73640     } catch (Dali::DaliException e) {
73641       {
73642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73643       };
73644     } catch (...) {
73645       {
73646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73647       };
73648     }
73649   }
73650
73651   jresult = (void *)result;
73652   return jresult;
73653 }
73654
73655
73656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73657   int jresult ;
73658   int result;
73659
73660   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73661   jresult = (int)result;
73662   return jresult;
73663 }
73664
73665
73666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73667   int jresult ;
73668   int result;
73669
73670   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73671   jresult = (int)result;
73672   return jresult;
73673 }
73674
73675
73676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73677   int jresult ;
73678   int result;
73679
73680   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73681   jresult = (int)result;
73682   return jresult;
73683 }
73684
73685
73686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73687   int jresult ;
73688   int result;
73689
73690   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73691   jresult = (int)result;
73692   return jresult;
73693 }
73694
73695
73696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73697   int jresult ;
73698   int result;
73699
73700   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73701   jresult = (int)result;
73702   return jresult;
73703 }
73704
73705
73706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73707   int jresult ;
73708   int result;
73709
73710   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73711   jresult = (int)result;
73712   return jresult;
73713 }
73714
73715
73716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73717   int jresult ;
73718   int result;
73719
73720   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73721   jresult = (int)result;
73722   return jresult;
73723 }
73724
73725
73726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73727   int jresult ;
73728   int result;
73729
73730   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73731   jresult = (int)result;
73732   return jresult;
73733 }
73734
73735
73736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73737   int jresult ;
73738   int result;
73739
73740   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73741   jresult = (int)result;
73742   return jresult;
73743 }
73744
73745
73746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73747   int jresult ;
73748   int result;
73749
73750   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73751   jresult = (int)result;
73752   return jresult;
73753 }
73754
73755
73756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73757   int jresult ;
73758   int result;
73759
73760   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73761   jresult = (int)result;
73762   return jresult;
73763 }
73764
73765
73766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73767   int jresult ;
73768   int result;
73769
73770   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73771   jresult = (int)result;
73772   return jresult;
73773 }
73774
73775
73776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73777   int jresult ;
73778   int result;
73779
73780   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73781   jresult = (int)result;
73782   return jresult;
73783 }
73784
73785
73786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73787   int jresult ;
73788   int result;
73789
73790   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73791   jresult = (int)result;
73792   return jresult;
73793 }
73794
73795
73796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73797   void * jresult ;
73798   Dali::Toolkit::Scrollable::Property *result = 0 ;
73799
73800   {
73801     try {
73802       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73803     } catch (std::out_of_range& e) {
73804       {
73805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73806       };
73807     } catch (std::exception& e) {
73808       {
73809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73810       };
73811     } catch (Dali::DaliException e) {
73812       {
73813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73814       };
73815     } catch (...) {
73816       {
73817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73818       };
73819     }
73820   }
73821
73822   jresult = (void *)result;
73823   return jresult;
73824 }
73825
73826
73827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73828   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73829
73830   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73831   {
73832     try {
73833       delete arg1;
73834     } catch (std::out_of_range& e) {
73835       {
73836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73837       };
73838     } catch (std::exception& e) {
73839       {
73840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73841       };
73842     } catch (Dali::DaliException e) {
73843       {
73844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73845       };
73846     } catch (...) {
73847       {
73848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73849       };
73850     }
73851   }
73852
73853 }
73854
73855
73856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73857   void * jresult ;
73858   Dali::Toolkit::Scrollable *result = 0 ;
73859
73860   {
73861     try {
73862       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73863     } catch (std::out_of_range& e) {
73864       {
73865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73866       };
73867     } catch (std::exception& e) {
73868       {
73869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73870       };
73871     } catch (Dali::DaliException e) {
73872       {
73873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73874       };
73875     } catch (...) {
73876       {
73877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73878       };
73879     }
73880   }
73881
73882   jresult = (void *)result;
73883   return jresult;
73884 }
73885
73886
73887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73888   void * jresult ;
73889   Dali::Toolkit::Scrollable *arg1 = 0 ;
73890   Dali::Toolkit::Scrollable *result = 0 ;
73891
73892   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73893   if (!arg1) {
73894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73895     return 0;
73896   }
73897   {
73898     try {
73899       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73900     } catch (std::out_of_range& e) {
73901       {
73902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73903       };
73904     } catch (std::exception& e) {
73905       {
73906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73907       };
73908     } catch (Dali::DaliException e) {
73909       {
73910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73911       };
73912     } catch (...) {
73913       {
73914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73915       };
73916     }
73917   }
73918
73919   jresult = (void *)result;
73920   return jresult;
73921 }
73922
73923
73924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73925   void * jresult ;
73926   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73927   Dali::Toolkit::Scrollable *arg2 = 0 ;
73928   Dali::Toolkit::Scrollable *result = 0 ;
73929
73930   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73931   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73932   if (!arg2) {
73933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73934     return 0;
73935   }
73936   {
73937     try {
73938       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73939     } catch (std::out_of_range& e) {
73940       {
73941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73942       };
73943     } catch (std::exception& e) {
73944       {
73945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73946       };
73947     } catch (Dali::DaliException e) {
73948       {
73949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73950       };
73951     } catch (...) {
73952       {
73953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73954       };
73955     }
73956   }
73957
73958   jresult = (void *)result;
73959   return jresult;
73960 }
73961
73962
73963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73964   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73965
73966   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73967   {
73968     try {
73969       delete arg1;
73970     } catch (std::out_of_range& e) {
73971       {
73972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73973       };
73974     } catch (std::exception& e) {
73975       {
73976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73977       };
73978     } catch (Dali::DaliException e) {
73979       {
73980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73981       };
73982     } catch (...) {
73983       {
73984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73985       };
73986     }
73987   }
73988
73989 }
73990
73991
73992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73993   void * jresult ;
73994   Dali::BaseHandle arg1 ;
73995   Dali::BaseHandle *argp1 ;
73996   Dali::Toolkit::Scrollable result;
73997
73998   argp1 = (Dali::BaseHandle *)jarg1;
73999   if (!argp1) {
74000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74001     return 0;
74002   }
74003   arg1 = *argp1;
74004   {
74005     try {
74006       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74007     } catch (std::out_of_range& e) {
74008       {
74009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74010       };
74011     } catch (std::exception& e) {
74012       {
74013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74014       };
74015     } catch (Dali::DaliException e) {
74016       {
74017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74018       };
74019     } catch (...) {
74020       {
74021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74022       };
74023     }
74024   }
74025
74026   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74027   return jresult;
74028 }
74029
74030
74031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74032   unsigned int jresult ;
74033   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74034   bool result;
74035
74036   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74037   {
74038     try {
74039       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74040     } catch (std::out_of_range& e) {
74041       {
74042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74043       };
74044     } catch (std::exception& e) {
74045       {
74046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74047       };
74048     } catch (Dali::DaliException e) {
74049       {
74050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74051       };
74052     } catch (...) {
74053       {
74054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74055       };
74056     }
74057   }
74058
74059   jresult = result;
74060   return jresult;
74061 }
74062
74063
74064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74065   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74066   bool arg2 ;
74067
74068   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74069   arg2 = jarg2 ? true : false;
74070   {
74071     try {
74072       (arg1)->SetOvershootEnabled(arg2);
74073     } catch (std::out_of_range& e) {
74074       {
74075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74076       };
74077     } catch (std::exception& e) {
74078       {
74079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74080       };
74081     } catch (Dali::DaliException e) {
74082       {
74083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74084       };
74085     } catch (...) {
74086       {
74087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74088       };
74089     }
74090   }
74091
74092 }
74093
74094
74095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74096   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74097   Dali::Vector4 *arg2 = 0 ;
74098
74099   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74100   arg2 = (Dali::Vector4 *)jarg2;
74101   if (!arg2) {
74102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74103     return ;
74104   }
74105   {
74106     try {
74107       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74108     } catch (std::out_of_range& e) {
74109       {
74110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74111       };
74112     } catch (std::exception& e) {
74113       {
74114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74115       };
74116     } catch (Dali::DaliException e) {
74117       {
74118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74119       };
74120     } catch (...) {
74121       {
74122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74123       };
74124     }
74125   }
74126
74127 }
74128
74129
74130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74131   void * jresult ;
74132   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74133   Dali::Vector4 result;
74134
74135   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74136   {
74137     try {
74138       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74139     } catch (std::out_of_range& e) {
74140       {
74141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74142       };
74143     } catch (std::exception& e) {
74144       {
74145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74146       };
74147     } catch (Dali::DaliException e) {
74148       {
74149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74150       };
74151     } catch (...) {
74152       {
74153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74154       };
74155     }
74156   }
74157
74158   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74159   return jresult;
74160 }
74161
74162
74163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74164   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74165   float arg2 ;
74166
74167   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74168   arg2 = (float)jarg2;
74169   {
74170     try {
74171       (arg1)->SetOvershootAnimationSpeed(arg2);
74172     } catch (std::out_of_range& e) {
74173       {
74174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74175       };
74176     } catch (std::exception& e) {
74177       {
74178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74179       };
74180     } catch (Dali::DaliException e) {
74181       {
74182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74183       };
74184     } catch (...) {
74185       {
74186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74187       };
74188     }
74189   }
74190
74191 }
74192
74193
74194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74195   float jresult ;
74196   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74197   float result;
74198
74199   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74200   {
74201     try {
74202       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74203     } catch (std::out_of_range& e) {
74204       {
74205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74206       };
74207     } catch (std::exception& e) {
74208       {
74209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74210       };
74211     } catch (Dali::DaliException e) {
74212       {
74213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74214       };
74215     } catch (...) {
74216       {
74217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74218       };
74219     }
74220   }
74221
74222   jresult = result;
74223   return jresult;
74224 }
74225
74226
74227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74228   void * jresult ;
74229   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74230   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74231
74232   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74233   {
74234     try {
74235       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74236     } catch (std::out_of_range& e) {
74237       {
74238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74239       };
74240     } catch (std::exception& e) {
74241       {
74242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74243       };
74244     } catch (Dali::DaliException e) {
74245       {
74246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74247       };
74248     } catch (...) {
74249       {
74250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74251       };
74252     }
74253   }
74254
74255   jresult = (void *)result;
74256   return jresult;
74257 }
74258
74259
74260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74261   void * jresult ;
74262   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74263   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74264
74265   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74266   {
74267     try {
74268       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74269     } catch (std::out_of_range& e) {
74270       {
74271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74272       };
74273     } catch (std::exception& e) {
74274       {
74275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74276       };
74277     } catch (Dali::DaliException e) {
74278       {
74279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74280       };
74281     } catch (...) {
74282       {
74283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74284       };
74285     }
74286   }
74287
74288   jresult = (void *)result;
74289   return jresult;
74290 }
74291
74292
74293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74294   void * jresult ;
74295   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74296   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74297
74298   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74299   {
74300     try {
74301       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74302     } catch (std::out_of_range& e) {
74303       {
74304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74305       };
74306     } catch (std::exception& e) {
74307       {
74308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74309       };
74310     } catch (Dali::DaliException e) {
74311       {
74312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74313       };
74314     } catch (...) {
74315       {
74316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74317       };
74318     }
74319   }
74320
74321   jresult = (void *)result;
74322   return jresult;
74323 }
74324
74325
74326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74327   unsigned int jresult ;
74328   Dali::Toolkit::ControlOrientation::Type arg1 ;
74329   bool result;
74330
74331   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74332   {
74333     try {
74334       result = (bool)Dali::Toolkit::IsVertical(arg1);
74335     } catch (std::out_of_range& e) {
74336       {
74337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74338       };
74339     } catch (std::exception& e) {
74340       {
74341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74342       };
74343     } catch (Dali::DaliException e) {
74344       {
74345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74346       };
74347     } catch (...) {
74348       {
74349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74350       };
74351     }
74352   }
74353
74354   jresult = result;
74355   return jresult;
74356 }
74357
74358
74359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74360   unsigned int jresult ;
74361   Dali::Toolkit::ControlOrientation::Type arg1 ;
74362   bool result;
74363
74364   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74365   {
74366     try {
74367       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74368     } catch (std::out_of_range& e) {
74369       {
74370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74371       };
74372     } catch (std::exception& e) {
74373       {
74374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74375       };
74376     } catch (Dali::DaliException e) {
74377       {
74378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74379       };
74380     } catch (...) {
74381       {
74382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74383       };
74384     }
74385   }
74386
74387   jresult = result;
74388   return jresult;
74389 }
74390
74391
74392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74393   void * jresult ;
74394   unsigned int arg1 ;
74395   unsigned int arg2 ;
74396   Dali::Toolkit::ItemRange *result = 0 ;
74397
74398   arg1 = (unsigned int)jarg1;
74399   arg2 = (unsigned int)jarg2;
74400   {
74401     try {
74402       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74403     } catch (std::out_of_range& e) {
74404       {
74405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74406       };
74407     } catch (std::exception& e) {
74408       {
74409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74410       };
74411     } catch (Dali::DaliException e) {
74412       {
74413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74414       };
74415     } catch (...) {
74416       {
74417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74418       };
74419     }
74420   }
74421
74422   jresult = (void *)result;
74423   return jresult;
74424 }
74425
74426
74427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74428   void * jresult ;
74429   Dali::Toolkit::ItemRange *arg1 = 0 ;
74430   Dali::Toolkit::ItemRange *result = 0 ;
74431
74432   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74433   if (!arg1) {
74434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74435     return 0;
74436   }
74437   {
74438     try {
74439       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74440     } catch (std::out_of_range& e) {
74441       {
74442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74443       };
74444     } catch (std::exception& e) {
74445       {
74446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74447       };
74448     } catch (Dali::DaliException e) {
74449       {
74450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74451       };
74452     } catch (...) {
74453       {
74454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74455       };
74456     }
74457   }
74458
74459   jresult = (void *)result;
74460   return jresult;
74461 }
74462
74463
74464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74465   void * jresult ;
74466   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74467   Dali::Toolkit::ItemRange *arg2 = 0 ;
74468   Dali::Toolkit::ItemRange *result = 0 ;
74469
74470   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74471   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74472   if (!arg2) {
74473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74474     return 0;
74475   }
74476   {
74477     try {
74478       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74479     } catch (std::out_of_range& e) {
74480       {
74481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74482       };
74483     } catch (std::exception& e) {
74484       {
74485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74486       };
74487     } catch (Dali::DaliException e) {
74488       {
74489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74490       };
74491     } catch (...) {
74492       {
74493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74494       };
74495     }
74496   }
74497
74498   jresult = (void *)result;
74499   return jresult;
74500 }
74501
74502
74503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74504   unsigned int jresult ;
74505   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74506   unsigned int arg2 ;
74507   bool result;
74508
74509   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74510   arg2 = (unsigned int)jarg2;
74511   {
74512     try {
74513       result = (bool)(arg1)->Within(arg2);
74514     } catch (std::out_of_range& e) {
74515       {
74516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74517       };
74518     } catch (std::exception& e) {
74519       {
74520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74521       };
74522     } catch (Dali::DaliException e) {
74523       {
74524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74525       };
74526     } catch (...) {
74527       {
74528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74529       };
74530     }
74531   }
74532
74533   jresult = result;
74534   return jresult;
74535 }
74536
74537
74538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74539   void * jresult ;
74540   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74541   Dali::Toolkit::ItemRange *arg2 = 0 ;
74542   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74543
74544   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74545   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74546   if (!arg2) {
74547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74548     return 0;
74549   }
74550   {
74551     try {
74552       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74553     } catch (std::out_of_range& e) {
74554       {
74555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74556       };
74557     } catch (std::exception& e) {
74558       {
74559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74560       };
74561     } catch (Dali::DaliException e) {
74562       {
74563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74564       };
74565     } catch (...) {
74566       {
74567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74568       };
74569     }
74570   }
74571
74572   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74573   return jresult;
74574 }
74575
74576
74577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74578   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74579   unsigned int arg2 ;
74580
74581   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74582   arg2 = (unsigned int)jarg2;
74583   if (arg1) (arg1)->begin = arg2;
74584 }
74585
74586
74587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74588   unsigned int jresult ;
74589   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74590   unsigned int result;
74591
74592   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74593   result = (unsigned int) ((arg1)->begin);
74594   jresult = result;
74595   return jresult;
74596 }
74597
74598
74599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74600   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74601   unsigned int arg2 ;
74602
74603   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74604   arg2 = (unsigned int)jarg2;
74605   if (arg1) (arg1)->end = arg2;
74606 }
74607
74608
74609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74610   unsigned int jresult ;
74611   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74612   unsigned int result;
74613
74614   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74615   result = (unsigned int) ((arg1)->end);
74616   jresult = result;
74617   return jresult;
74618 }
74619
74620
74621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74622   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74623
74624   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74625   {
74626     try {
74627       delete arg1;
74628     } catch (std::out_of_range& e) {
74629       {
74630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74631       };
74632     } catch (std::exception& e) {
74633       {
74634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74635       };
74636     } catch (Dali::DaliException e) {
74637       {
74638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74639       };
74640     } catch (...) {
74641       {
74642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74643       };
74644     }
74645   }
74646
74647 }
74648
74649
74650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74651   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74652
74653   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74654   {
74655     try {
74656       delete arg1;
74657     } catch (std::out_of_range& e) {
74658       {
74659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74660       };
74661     } catch (std::exception& e) {
74662       {
74663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74664       };
74665     } catch (Dali::DaliException e) {
74666       {
74667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74668       };
74669     } catch (...) {
74670       {
74671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74672       };
74673     }
74674   }
74675
74676 }
74677
74678
74679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74680   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74681   Dali::Toolkit::ControlOrientation::Type arg2 ;
74682
74683   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74684   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74685   {
74686     try {
74687       (arg1)->SetOrientation(arg2);
74688     } catch (std::out_of_range& e) {
74689       {
74690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74691       };
74692     } catch (std::exception& e) {
74693       {
74694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74695       };
74696     } catch (Dali::DaliException e) {
74697       {
74698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74699       };
74700     } catch (...) {
74701       {
74702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74703       };
74704     }
74705   }
74706
74707 }
74708
74709
74710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74711   int jresult ;
74712   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74713   Dali::Toolkit::ControlOrientation::Type result;
74714
74715   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74716   {
74717     try {
74718       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74719     } catch (std::out_of_range& e) {
74720       {
74721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74722       };
74723     } catch (std::exception& e) {
74724       {
74725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74726       };
74727     } catch (Dali::DaliException e) {
74728       {
74729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74730       };
74731     } catch (...) {
74732       {
74733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74734       };
74735     }
74736   }
74737
74738   jresult = (int)result;
74739   return jresult;
74740 }
74741
74742
74743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74744   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74745   Dali::Property::Map *arg2 = 0 ;
74746
74747   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74748   arg2 = (Dali::Property::Map *)jarg2;
74749   if (!arg2) {
74750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74751     return ;
74752   }
74753   {
74754     try {
74755       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74756     } catch (std::out_of_range& e) {
74757       {
74758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74759       };
74760     } catch (std::exception& e) {
74761       {
74762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74763       };
74764     } catch (Dali::DaliException e) {
74765       {
74766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74767       };
74768     } catch (...) {
74769       {
74770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74771       };
74772     }
74773   }
74774
74775 }
74776
74777
74778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74779   void * jresult ;
74780   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74781   Dali::Property::Map result;
74782
74783   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74784   {
74785     try {
74786       result = (arg1)->GetLayoutProperties();
74787     } catch (std::out_of_range& e) {
74788       {
74789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74790       };
74791     } catch (std::exception& e) {
74792       {
74793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74794       };
74795     } catch (Dali::DaliException e) {
74796       {
74797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74798       };
74799     } catch (...) {
74800       {
74801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74802       };
74803     }
74804   }
74805
74806   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74807   return jresult;
74808 }
74809
74810
74811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74812   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74813   unsigned int arg2 ;
74814   Dali::Vector3 *arg3 = 0 ;
74815   Dali::Vector3 *arg4 = 0 ;
74816
74817   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74818   arg2 = (unsigned int)jarg2;
74819   arg3 = (Dali::Vector3 *)jarg3;
74820   if (!arg3) {
74821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74822     return ;
74823   }
74824   arg4 = (Dali::Vector3 *)jarg4;
74825   if (!arg4) {
74826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74827     return ;
74828   }
74829   {
74830     try {
74831       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74832     } catch (std::out_of_range& e) {
74833       {
74834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74835       };
74836     } catch (std::exception& e) {
74837       {
74838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74839       };
74840     } catch (Dali::DaliException e) {
74841       {
74842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74843       };
74844     } catch (...) {
74845       {
74846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74847       };
74848     }
74849   }
74850
74851 }
74852
74853
74854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74855   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74856   Dali::Vector3 *arg2 = 0 ;
74857
74858   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74859   arg2 = (Dali::Vector3 *)jarg2;
74860   if (!arg2) {
74861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74862     return ;
74863   }
74864   {
74865     try {
74866       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74867     } catch (std::out_of_range& e) {
74868       {
74869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74870       };
74871     } catch (std::exception& e) {
74872       {
74873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74874       };
74875     } catch (Dali::DaliException e) {
74876       {
74877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74878       };
74879     } catch (...) {
74880       {
74881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74882       };
74883     }
74884   }
74885
74886 }
74887
74888
74889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74890   float jresult ;
74891   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74892   unsigned int arg2 ;
74893   Dali::Vector3 arg3 ;
74894   Dali::Vector3 *argp3 ;
74895   float result;
74896
74897   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74898   arg2 = (unsigned int)jarg2;
74899   argp3 = (Dali::Vector3 *)jarg3;
74900   if (!argp3) {
74901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74902     return 0;
74903   }
74904   arg3 = *argp3;
74905   {
74906     try {
74907       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74908     } catch (std::out_of_range& e) {
74909       {
74910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74911       };
74912     } catch (std::exception& e) {
74913       {
74914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74915       };
74916     } catch (Dali::DaliException e) {
74917       {
74918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74919       };
74920     } catch (...) {
74921       {
74922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74923       };
74924     }
74925   }
74926
74927   jresult = result;
74928   return jresult;
74929 }
74930
74931
74932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74933   float jresult ;
74934   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74935   float arg2 ;
74936   float result;
74937
74938   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74939   arg2 = (float)jarg2;
74940   {
74941     try {
74942       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74943     } catch (std::out_of_range& e) {
74944       {
74945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74946       };
74947     } catch (std::exception& e) {
74948       {
74949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74950       };
74951     } catch (Dali::DaliException e) {
74952       {
74953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74954       };
74955     } catch (...) {
74956       {
74957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74958       };
74959     }
74960   }
74961
74962   jresult = result;
74963   return jresult;
74964 }
74965
74966
74967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74968   float jresult ;
74969   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74970   unsigned int arg2 ;
74971   float result;
74972
74973   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74974   arg2 = (unsigned int)jarg2;
74975   {
74976     try {
74977       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74978     } catch (std::out_of_range& e) {
74979       {
74980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74981       };
74982     } catch (std::exception& e) {
74983       {
74984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74985       };
74986     } catch (Dali::DaliException e) {
74987       {
74988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74989       };
74990     } catch (...) {
74991       {
74992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74993       };
74994     }
74995   }
74996
74997   jresult = result;
74998   return jresult;
74999 }
75000
75001
75002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75003   void * jresult ;
75004   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75005   float arg2 ;
75006   Dali::Vector3 arg3 ;
75007   Dali::Vector3 *argp3 ;
75008   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75009
75010   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75011   arg2 = (float)jarg2;
75012   argp3 = (Dali::Vector3 *)jarg3;
75013   if (!argp3) {
75014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75015     return 0;
75016   }
75017   arg3 = *argp3;
75018   {
75019     try {
75020       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75021     } catch (std::out_of_range& e) {
75022       {
75023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75024       };
75025     } catch (std::exception& e) {
75026       {
75027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75028       };
75029     } catch (Dali::DaliException e) {
75030       {
75031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75032       };
75033     } catch (...) {
75034       {
75035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75036       };
75037     }
75038   }
75039
75040   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75041   return jresult;
75042 }
75043
75044
75045 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75046   float jresult ;
75047   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75048   int arg2 ;
75049   float arg3 ;
75050   Dali::Vector3 *arg4 = 0 ;
75051   float result;
75052
75053   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75054   arg2 = (int)jarg2;
75055   arg3 = (float)jarg3;
75056   arg4 = (Dali::Vector3 *)jarg4;
75057   if (!arg4) {
75058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75059     return 0;
75060   }
75061   {
75062     try {
75063       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75064     } catch (std::out_of_range& e) {
75065       {
75066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75067       };
75068     } catch (std::exception& e) {
75069       {
75070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75071       };
75072     } catch (Dali::DaliException e) {
75073       {
75074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75075       };
75076     } catch (...) {
75077       {
75078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75079       };
75080     }
75081   }
75082
75083   jresult = result;
75084   return jresult;
75085 }
75086
75087
75088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75089   unsigned int jresult ;
75090   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75091   Dali::Vector3 arg2 ;
75092   Dali::Vector3 *argp2 ;
75093   unsigned int result;
75094
75095   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75096   argp2 = (Dali::Vector3 *)jarg2;
75097   if (!argp2) {
75098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75099     return 0;
75100   }
75101   arg2 = *argp2;
75102   {
75103     try {
75104       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75105     } catch (std::out_of_range& e) {
75106       {
75107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75108       };
75109     } catch (std::exception& e) {
75110       {
75111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75112       };
75113     } catch (Dali::DaliException e) {
75114       {
75115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75116       };
75117     } catch (...) {
75118       {
75119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75120       };
75121     }
75122   }
75123
75124   jresult = result;
75125   return jresult;
75126 }
75127
75128
75129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75130   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75131   unsigned int arg2 ;
75132   Dali::Vector3 *arg3 = 0 ;
75133   Dali::Vector3 *arg4 = 0 ;
75134
75135   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75136   arg2 = (unsigned int)jarg2;
75137   arg3 = (Dali::Vector3 *)jarg3;
75138   if (!arg3) {
75139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75140     return ;
75141   }
75142   arg4 = (Dali::Vector3 *)jarg4;
75143   if (!arg4) {
75144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75145     return ;
75146   }
75147   {
75148     try {
75149       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75150     } catch (std::out_of_range& e) {
75151       {
75152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75153       };
75154     } catch (std::exception& e) {
75155       {
75156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75157       };
75158     } catch (Dali::DaliException e) {
75159       {
75160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75161       };
75162     } catch (...) {
75163       {
75164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75165       };
75166     }
75167   }
75168
75169 }
75170
75171
75172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75173   void * jresult ;
75174   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75175   Dali::Degree result;
75176
75177   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75178   {
75179     try {
75180       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75181     } catch (std::out_of_range& e) {
75182       {
75183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75184       };
75185     } catch (std::exception& e) {
75186       {
75187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75188       };
75189     } catch (Dali::DaliException e) {
75190       {
75191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75192       };
75193     } catch (...) {
75194       {
75195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75196       };
75197     }
75198   }
75199
75200   jresult = new Dali::Degree((const Dali::Degree &)result);
75201   return jresult;
75202 }
75203
75204
75205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75206   float jresult ;
75207   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75208   float result;
75209
75210   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75211   {
75212     try {
75213       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75214     } catch (std::out_of_range& e) {
75215       {
75216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75217       };
75218     } catch (std::exception& e) {
75219       {
75220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75221       };
75222     } catch (Dali::DaliException e) {
75223       {
75224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75225       };
75226     } catch (...) {
75227       {
75228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75229       };
75230     }
75231   }
75232
75233   jresult = result;
75234   return jresult;
75235 }
75236
75237
75238 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75239   float jresult ;
75240   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75241   float result;
75242
75243   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75244   {
75245     try {
75246       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75247     } catch (std::out_of_range& e) {
75248       {
75249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75250       };
75251     } catch (std::exception& e) {
75252       {
75253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75254       };
75255     } catch (Dali::DaliException e) {
75256       {
75257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75258       };
75259     } catch (...) {
75260       {
75261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75262       };
75263     }
75264   }
75265
75266   jresult = result;
75267   return jresult;
75268 }
75269
75270
75271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75272   float jresult ;
75273   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75274   float result;
75275
75276   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75277   {
75278     try {
75279       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75280     } catch (std::out_of_range& e) {
75281       {
75282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75283       };
75284     } catch (std::exception& e) {
75285       {
75286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75287       };
75288     } catch (Dali::DaliException e) {
75289       {
75290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75291       };
75292     } catch (...) {
75293       {
75294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75295       };
75296     }
75297   }
75298
75299   jresult = result;
75300   return jresult;
75301 }
75302
75303
75304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75305   int jresult ;
75306   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75307   int arg2 ;
75308   int arg3 ;
75309   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75310   bool arg5 ;
75311   int result;
75312
75313   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75314   arg2 = (int)jarg2;
75315   arg3 = (int)jarg3;
75316   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75317   arg5 = jarg5 ? true : false;
75318   {
75319     try {
75320       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75321     } catch (std::out_of_range& e) {
75322       {
75323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75324       };
75325     } catch (std::exception& e) {
75326       {
75327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75328       };
75329     } catch (Dali::DaliException e) {
75330       {
75331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75332       };
75333     } catch (...) {
75334       {
75335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75336       };
75337     }
75338   }
75339
75340   jresult = result;
75341   return jresult;
75342 }
75343
75344
75345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75346   float jresult ;
75347   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75348   float result;
75349
75350   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75351   {
75352     try {
75353       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75354     } catch (std::out_of_range& e) {
75355       {
75356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75357       };
75358     } catch (std::exception& e) {
75359       {
75360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75361       };
75362     } catch (Dali::DaliException e) {
75363       {
75364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75365       };
75366     } catch (...) {
75367       {
75368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75369       };
75370     }
75371   }
75372
75373   jresult = result;
75374   return jresult;
75375 }
75376
75377
75378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75379   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75380   Dali::Actor *arg2 = 0 ;
75381   int arg3 ;
75382   Dali::Vector3 *arg4 = 0 ;
75383   Dali::Actor *arg5 = 0 ;
75384
75385   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75386   arg2 = (Dali::Actor *)jarg2;
75387   if (!arg2) {
75388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75389     return ;
75390   }
75391   arg3 = (int)jarg3;
75392   arg4 = (Dali::Vector3 *)jarg4;
75393   if (!arg4) {
75394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75395     return ;
75396   }
75397   arg5 = (Dali::Actor *)jarg5;
75398   if (!arg5) {
75399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75400     return ;
75401   }
75402   {
75403     try {
75404       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75405     } catch (std::out_of_range& e) {
75406       {
75407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75408       };
75409     } catch (std::exception& e) {
75410       {
75411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75412       };
75413     } catch (Dali::DaliException e) {
75414       {
75415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75416       };
75417     } catch (...) {
75418       {
75419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75420       };
75421     }
75422   }
75423
75424 }
75425
75426
75427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75428   void * jresult ;
75429   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75430   int arg2 ;
75431   float arg3 ;
75432   Dali::Vector3 *arg4 = 0 ;
75433   Dali::Vector3 result;
75434
75435   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75436   arg2 = (int)jarg2;
75437   arg3 = (float)jarg3;
75438   arg4 = (Dali::Vector3 *)jarg4;
75439   if (!arg4) {
75440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75441     return 0;
75442   }
75443   {
75444     try {
75445       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75446     } catch (std::out_of_range& e) {
75447       {
75448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75449       };
75450     } catch (std::exception& e) {
75451       {
75452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75453       };
75454     } catch (Dali::DaliException e) {
75455       {
75456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75457       };
75458     } catch (...) {
75459       {
75460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75461       };
75462     }
75463   }
75464
75465   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75466   return jresult;
75467 }
75468
75469
75470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75471   void * jresult ;
75472   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75473   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75474
75475   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75476   {
75477     try {
75478       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75479     } catch (std::out_of_range& e) {
75480       {
75481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75482       };
75483     } catch (std::exception& e) {
75484       {
75485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75486       };
75487     } catch (Dali::DaliException e) {
75488       {
75489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75490       };
75491     } catch (...) {
75492       {
75493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75494       };
75495     }
75496   }
75497
75498   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75499   return jresult;
75500 }
75501
75502
75503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75504   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75505
75506   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75507   {
75508     try {
75509       delete arg1;
75510     } catch (std::out_of_range& e) {
75511       {
75512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75513       };
75514     } catch (std::exception& e) {
75515       {
75516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75517       };
75518     } catch (Dali::DaliException e) {
75519       {
75520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75521       };
75522     } catch (...) {
75523       {
75524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75525       };
75526     }
75527   }
75528
75529 }
75530
75531
75532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75533   unsigned int jresult ;
75534   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75535   unsigned int result;
75536
75537   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75538   {
75539     try {
75540       result = (unsigned int)(arg1)->GetNumberOfItems();
75541     } catch (std::out_of_range& e) {
75542       {
75543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75544       };
75545     } catch (std::exception& e) {
75546       {
75547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75548       };
75549     } catch (Dali::DaliException e) {
75550       {
75551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75552       };
75553     } catch (...) {
75554       {
75555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75556       };
75557     }
75558   }
75559
75560   jresult = result;
75561   return jresult;
75562 }
75563
75564
75565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75566   void * jresult ;
75567   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75568   unsigned int arg2 ;
75569   Dali::Actor result;
75570
75571   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75572   arg2 = (unsigned int)jarg2;
75573   {
75574     try {
75575       result = (arg1)->NewItem(arg2);
75576     } catch (std::out_of_range& e) {
75577       {
75578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75579       };
75580     } catch (std::exception& e) {
75581       {
75582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75583       };
75584     } catch (Dali::DaliException e) {
75585       {
75586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75587       };
75588     } catch (...) {
75589       {
75590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75591       };
75592     }
75593   }
75594
75595   jresult = new Dali::Actor((const Dali::Actor &)result);
75596   return jresult;
75597 }
75598
75599
75600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75601   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75602   unsigned int arg2 ;
75603   Dali::Actor arg3 ;
75604   Dali::Actor *argp3 ;
75605
75606   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75607   arg2 = (unsigned int)jarg2;
75608   argp3 = (Dali::Actor *)jarg3;
75609   if (!argp3) {
75610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75611     return ;
75612   }
75613   arg3 = *argp3;
75614   {
75615     try {
75616       (arg1)->ItemReleased(arg2,arg3);
75617     } catch (std::out_of_range& e) {
75618       {
75619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75620       };
75621     } catch (std::exception& e) {
75622       {
75623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75624       };
75625     } catch (Dali::DaliException e) {
75626       {
75627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75628       };
75629     } catch (...) {
75630       {
75631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75632       };
75633     }
75634   }
75635
75636 }
75637
75638
75639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75640   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75641   unsigned int arg2 ;
75642   Dali::Actor arg3 ;
75643   Dali::Actor *argp3 ;
75644
75645   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75646   arg2 = (unsigned int)jarg2;
75647   argp3 = (Dali::Actor *)jarg3;
75648   if (!argp3) {
75649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75650     return ;
75651   }
75652   arg3 = *argp3;
75653   {
75654     try {
75655       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75656     } catch (std::out_of_range& e) {
75657       {
75658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75659       };
75660     } catch (std::exception& e) {
75661       {
75662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75663       };
75664     } catch (Dali::DaliException e) {
75665       {
75666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75667       };
75668     } catch (...) {
75669       {
75670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75671       };
75672     }
75673   }
75674
75675 }
75676
75677
75678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75679   void * jresult ;
75680   Dali::Toolkit::ItemFactory *result = 0 ;
75681
75682   {
75683     try {
75684       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75685     } catch (std::out_of_range& e) {
75686       {
75687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75688       };
75689     } catch (std::exception& e) {
75690       {
75691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75692       };
75693     } catch (Dali::DaliException e) {
75694       {
75695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75696       };
75697     } catch (...) {
75698       {
75699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75700       };
75701     }
75702   }
75703
75704   jresult = (void *)result;
75705   return jresult;
75706 }
75707
75708
75709 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) {
75710   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75711   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75712   if (director) {
75713     director->swig_connect_director(callback0, callback1, callback2);
75714   }
75715 }
75716
75717
75718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75719   int jresult ;
75720   int result;
75721
75722   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75723   jresult = (int)result;
75724   return jresult;
75725 }
75726
75727
75728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75729   int jresult ;
75730   int result;
75731
75732   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75733   jresult = (int)result;
75734   return jresult;
75735 }
75736
75737
75738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75739   int jresult ;
75740   int result;
75741
75742   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75743   jresult = (int)result;
75744   return jresult;
75745 }
75746
75747
75748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75749   int jresult ;
75750   int result;
75751
75752   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75753   jresult = (int)result;
75754   return jresult;
75755 }
75756
75757
75758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75759   int jresult ;
75760   int result;
75761
75762   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75763   jresult = (int)result;
75764   return jresult;
75765 }
75766
75767
75768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75769   int jresult ;
75770   int result;
75771
75772   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75773   jresult = (int)result;
75774   return jresult;
75775 }
75776
75777
75778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75779   int jresult ;
75780   int result;
75781
75782   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75783   jresult = (int)result;
75784   return jresult;
75785 }
75786
75787
75788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75789   int jresult ;
75790   int result;
75791
75792   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75793   jresult = (int)result;
75794   return jresult;
75795 }
75796
75797
75798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75799   int jresult ;
75800   int result;
75801
75802   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75803   jresult = (int)result;
75804   return jresult;
75805 }
75806
75807
75808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75809   int jresult ;
75810   int result;
75811
75812   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75813   jresult = (int)result;
75814   return jresult;
75815 }
75816
75817
75818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75819   int jresult ;
75820   int result;
75821
75822   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75823   jresult = (int)result;
75824   return jresult;
75825 }
75826
75827
75828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75829   void * jresult ;
75830   Dali::Toolkit::ItemView::Property *result = 0 ;
75831
75832   {
75833     try {
75834       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75835     } catch (std::out_of_range& e) {
75836       {
75837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75838       };
75839     } catch (std::exception& e) {
75840       {
75841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75842       };
75843     } catch (Dali::DaliException e) {
75844       {
75845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75846       };
75847     } catch (...) {
75848       {
75849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75850       };
75851     }
75852   }
75853
75854   jresult = (void *)result;
75855   return jresult;
75856 }
75857
75858
75859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75860   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75861
75862   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75863   {
75864     try {
75865       delete arg1;
75866     } catch (std::out_of_range& e) {
75867       {
75868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75869       };
75870     } catch (std::exception& e) {
75871       {
75872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75873       };
75874     } catch (Dali::DaliException e) {
75875       {
75876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75877       };
75878     } catch (...) {
75879       {
75880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75881       };
75882     }
75883   }
75884
75885 }
75886
75887
75888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75889   void * jresult ;
75890   Dali::Toolkit::ItemView *result = 0 ;
75891
75892   {
75893     try {
75894       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75895     } catch (std::out_of_range& e) {
75896       {
75897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75898       };
75899     } catch (std::exception& e) {
75900       {
75901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75902       };
75903     } catch (Dali::DaliException e) {
75904       {
75905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75906       };
75907     } catch (...) {
75908       {
75909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75910       };
75911     }
75912   }
75913
75914   jresult = (void *)result;
75915   return jresult;
75916 }
75917
75918
75919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75920   void * jresult ;
75921   Dali::Toolkit::ItemView *arg1 = 0 ;
75922   Dali::Toolkit::ItemView *result = 0 ;
75923
75924   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75925   if (!arg1) {
75926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75927     return 0;
75928   }
75929   {
75930     try {
75931       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75932     } catch (std::out_of_range& e) {
75933       {
75934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75935       };
75936     } catch (std::exception& e) {
75937       {
75938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75939       };
75940     } catch (Dali::DaliException e) {
75941       {
75942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75943       };
75944     } catch (...) {
75945       {
75946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75947       };
75948     }
75949   }
75950
75951   jresult = (void *)result;
75952   return jresult;
75953 }
75954
75955
75956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75957   void * jresult ;
75958   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75959   Dali::Toolkit::ItemView *arg2 = 0 ;
75960   Dali::Toolkit::ItemView *result = 0 ;
75961
75962   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75963   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75964   if (!arg2) {
75965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75966     return 0;
75967   }
75968   {
75969     try {
75970       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75971     } catch (std::out_of_range& e) {
75972       {
75973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75974       };
75975     } catch (std::exception& e) {
75976       {
75977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75978       };
75979     } catch (Dali::DaliException e) {
75980       {
75981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75982       };
75983     } catch (...) {
75984       {
75985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75986       };
75987     }
75988   }
75989
75990   jresult = (void *)result;
75991   return jresult;
75992 }
75993
75994
75995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75996   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75997
75998   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75999   {
76000     try {
76001       delete arg1;
76002     } catch (std::out_of_range& e) {
76003       {
76004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76005       };
76006     } catch (std::exception& e) {
76007       {
76008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76009       };
76010     } catch (Dali::DaliException e) {
76011       {
76012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76013       };
76014     } catch (...) {
76015       {
76016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76017       };
76018     }
76019   }
76020
76021 }
76022
76023
76024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76025   void * jresult ;
76026   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76027   Dali::Toolkit::ItemView result;
76028
76029   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76030   if (!arg1) {
76031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76032     return 0;
76033   }
76034   {
76035     try {
76036       result = Dali::Toolkit::ItemView::New(*arg1);
76037     } catch (std::out_of_range& e) {
76038       {
76039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76040       };
76041     } catch (std::exception& e) {
76042       {
76043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76044       };
76045     } catch (Dali::DaliException e) {
76046       {
76047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76048       };
76049     } catch (...) {
76050       {
76051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76052       };
76053     }
76054   }
76055
76056   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76057   return jresult;
76058 }
76059
76060
76061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76062   void * jresult ;
76063   Dali::BaseHandle arg1 ;
76064   Dali::BaseHandle *argp1 ;
76065   Dali::Toolkit::ItemView result;
76066
76067   argp1 = (Dali::BaseHandle *)jarg1;
76068   if (!argp1) {
76069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76070     return 0;
76071   }
76072   arg1 = *argp1;
76073   {
76074     try {
76075       result = Dali::Toolkit::ItemView::DownCast(arg1);
76076     } catch (std::out_of_range& e) {
76077       {
76078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76079       };
76080     } catch (std::exception& e) {
76081       {
76082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76083       };
76084     } catch (Dali::DaliException e) {
76085       {
76086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76087       };
76088     } catch (...) {
76089       {
76090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76091       };
76092     }
76093   }
76094
76095   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76096   return jresult;
76097 }
76098
76099
76100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76101   unsigned int jresult ;
76102   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76103   unsigned int result;
76104
76105   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76106   {
76107     try {
76108       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76109     } catch (std::out_of_range& e) {
76110       {
76111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76112       };
76113     } catch (std::exception& e) {
76114       {
76115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76116       };
76117     } catch (Dali::DaliException e) {
76118       {
76119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76120       };
76121     } catch (...) {
76122       {
76123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76124       };
76125     }
76126   }
76127
76128   jresult = result;
76129   return jresult;
76130 }
76131
76132
76133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76134   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76135   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76136
76137   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76138   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76139   if (!arg2) {
76140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76141     return ;
76142   }
76143   {
76144     try {
76145       (arg1)->AddLayout(*arg2);
76146     } catch (std::out_of_range& e) {
76147       {
76148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76149       };
76150     } catch (std::exception& e) {
76151       {
76152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76153       };
76154     } catch (Dali::DaliException e) {
76155       {
76156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76157       };
76158     } catch (...) {
76159       {
76160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76161       };
76162     }
76163   }
76164
76165 }
76166
76167
76168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76169   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76170   unsigned int arg2 ;
76171
76172   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76173   arg2 = (unsigned int)jarg2;
76174   {
76175     try {
76176       (arg1)->RemoveLayout(arg2);
76177     } catch (std::out_of_range& e) {
76178       {
76179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76180       };
76181     } catch (std::exception& e) {
76182       {
76183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76184       };
76185     } catch (Dali::DaliException e) {
76186       {
76187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76188       };
76189     } catch (...) {
76190       {
76191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76192       };
76193     }
76194   }
76195
76196 }
76197
76198
76199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76200   void * jresult ;
76201   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76202   unsigned int arg2 ;
76203   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76204
76205   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76206   arg2 = (unsigned int)jarg2;
76207   {
76208     try {
76209       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76210     } catch (std::out_of_range& e) {
76211       {
76212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76213       };
76214     } catch (std::exception& e) {
76215       {
76216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76217       };
76218     } catch (Dali::DaliException e) {
76219       {
76220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76221       };
76222     } catch (...) {
76223       {
76224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76225       };
76226     }
76227   }
76228
76229   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76230   return jresult;
76231 }
76232
76233
76234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76235   void * jresult ;
76236   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76237   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76238
76239   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76240   {
76241     try {
76242       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76243     } catch (std::out_of_range& e) {
76244       {
76245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76246       };
76247     } catch (std::exception& e) {
76248       {
76249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76250       };
76251     } catch (Dali::DaliException e) {
76252       {
76253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76254       };
76255     } catch (...) {
76256       {
76257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76258       };
76259     }
76260   }
76261
76262   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76263   return jresult;
76264 }
76265
76266
76267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76268   float jresult ;
76269   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76270   Dali::Toolkit::ItemId arg2 ;
76271   float result;
76272
76273   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76274   arg2 = (Dali::Toolkit::ItemId)jarg2;
76275   {
76276     try {
76277       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76278     } catch (std::out_of_range& e) {
76279       {
76280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76281       };
76282     } catch (std::exception& e) {
76283       {
76284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76285       };
76286     } catch (Dali::DaliException e) {
76287       {
76288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76289       };
76290     } catch (...) {
76291       {
76292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76293       };
76294     }
76295   }
76296
76297   jresult = result;
76298   return jresult;
76299 }
76300
76301
76302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76303   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76304   unsigned int arg2 ;
76305   Dali::Vector3 arg3 ;
76306   float arg4 ;
76307   Dali::Vector3 *argp3 ;
76308
76309   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76310   arg2 = (unsigned int)jarg2;
76311   argp3 = (Dali::Vector3 *)jarg3;
76312   if (!argp3) {
76313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76314     return ;
76315   }
76316   arg3 = *argp3;
76317   arg4 = (float)jarg4;
76318   {
76319     try {
76320       (arg1)->ActivateLayout(arg2,arg3,arg4);
76321     } catch (std::out_of_range& e) {
76322       {
76323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76324       };
76325     } catch (std::exception& e) {
76326       {
76327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76328       };
76329     } catch (Dali::DaliException e) {
76330       {
76331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76332       };
76333     } catch (...) {
76334       {
76335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76336       };
76337     }
76338   }
76339
76340 }
76341
76342
76343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76344   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76345
76346   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76347   {
76348     try {
76349       (arg1)->DeactivateCurrentLayout();
76350     } catch (std::out_of_range& e) {
76351       {
76352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76353       };
76354     } catch (std::exception& e) {
76355       {
76356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76357       };
76358     } catch (Dali::DaliException e) {
76359       {
76360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76361       };
76362     } catch (...) {
76363       {
76364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76365       };
76366     }
76367   }
76368
76369 }
76370
76371
76372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76373   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76374   float arg2 ;
76375
76376   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76377   arg2 = (float)jarg2;
76378   {
76379     try {
76380       (arg1)->SetMinimumSwipeSpeed(arg2);
76381     } catch (std::out_of_range& e) {
76382       {
76383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76384       };
76385     } catch (std::exception& e) {
76386       {
76387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76388       };
76389     } catch (Dali::DaliException e) {
76390       {
76391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76392       };
76393     } catch (...) {
76394       {
76395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76396       };
76397     }
76398   }
76399
76400 }
76401
76402
76403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76404   float jresult ;
76405   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76406   float result;
76407
76408   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76409   {
76410     try {
76411       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76412     } catch (std::out_of_range& e) {
76413       {
76414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76415       };
76416     } catch (std::exception& e) {
76417       {
76418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76419       };
76420     } catch (Dali::DaliException e) {
76421       {
76422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76423       };
76424     } catch (...) {
76425       {
76426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76427       };
76428     }
76429   }
76430
76431   jresult = result;
76432   return jresult;
76433 }
76434
76435
76436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76437   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76438   float arg2 ;
76439
76440   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76441   arg2 = (float)jarg2;
76442   {
76443     try {
76444       (arg1)->SetMinimumSwipeDistance(arg2);
76445     } catch (std::out_of_range& e) {
76446       {
76447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76448       };
76449     } catch (std::exception& e) {
76450       {
76451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76452       };
76453     } catch (Dali::DaliException e) {
76454       {
76455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76456       };
76457     } catch (...) {
76458       {
76459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76460       };
76461     }
76462   }
76463
76464 }
76465
76466
76467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76468   float jresult ;
76469   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76470   float result;
76471
76472   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76473   {
76474     try {
76475       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76476     } catch (std::out_of_range& e) {
76477       {
76478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76479       };
76480     } catch (std::exception& e) {
76481       {
76482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76483       };
76484     } catch (Dali::DaliException e) {
76485       {
76486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76487       };
76488     } catch (...) {
76489       {
76490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76491       };
76492     }
76493   }
76494
76495   jresult = result;
76496   return jresult;
76497 }
76498
76499
76500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76501   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76502   float arg2 ;
76503
76504   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76505   arg2 = (float)jarg2;
76506   {
76507     try {
76508       (arg1)->SetWheelScrollDistanceStep(arg2);
76509     } catch (std::out_of_range& e) {
76510       {
76511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76512       };
76513     } catch (std::exception& e) {
76514       {
76515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76516       };
76517     } catch (Dali::DaliException e) {
76518       {
76519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76520       };
76521     } catch (...) {
76522       {
76523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76524       };
76525     }
76526   }
76527
76528 }
76529
76530
76531 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76532   float jresult ;
76533   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76534   float result;
76535
76536   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76537   {
76538     try {
76539       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76540     } catch (std::out_of_range& e) {
76541       {
76542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76543       };
76544     } catch (std::exception& e) {
76545       {
76546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76547       };
76548     } catch (Dali::DaliException e) {
76549       {
76550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76551       };
76552     } catch (...) {
76553       {
76554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76555       };
76556     }
76557   }
76558
76559   jresult = result;
76560   return jresult;
76561 }
76562
76563
76564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76565   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76566   bool arg2 ;
76567
76568   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76569   arg2 = jarg2 ? true : false;
76570   {
76571     try {
76572       (arg1)->SetAnchoring(arg2);
76573     } catch (std::out_of_range& e) {
76574       {
76575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76576       };
76577     } catch (std::exception& e) {
76578       {
76579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76580       };
76581     } catch (Dali::DaliException e) {
76582       {
76583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76584       };
76585     } catch (...) {
76586       {
76587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76588       };
76589     }
76590   }
76591
76592 }
76593
76594 //// ========================= end of part 3 =============================
76595
76596 //// ========================== start part 4 ===============================
76597
76598
76599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76600   unsigned int jresult ;
76601   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76602   bool result;
76603
76604   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76605   {
76606     try {
76607       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76608     } catch (std::out_of_range& e) {
76609       {
76610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76611       };
76612     } catch (std::exception& e) {
76613       {
76614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76615       };
76616     } catch (Dali::DaliException e) {
76617       {
76618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76619       };
76620     } catch (...) {
76621       {
76622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76623       };
76624     }
76625   }
76626
76627   jresult = result;
76628   return jresult;
76629 }
76630
76631
76632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76633   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76634   float arg2 ;
76635
76636   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76637   arg2 = (float)jarg2;
76638   {
76639     try {
76640       (arg1)->SetAnchoringDuration(arg2);
76641     } catch (std::out_of_range& e) {
76642       {
76643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76644       };
76645     } catch (std::exception& e) {
76646       {
76647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76648       };
76649     } catch (Dali::DaliException e) {
76650       {
76651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76652       };
76653     } catch (...) {
76654       {
76655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76656       };
76657     }
76658   }
76659
76660 }
76661
76662
76663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76664   float jresult ;
76665   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76666   float result;
76667
76668   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76669   {
76670     try {
76671       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76672     } catch (std::out_of_range& e) {
76673       {
76674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76675       };
76676     } catch (std::exception& e) {
76677       {
76678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76679       };
76680     } catch (Dali::DaliException e) {
76681       {
76682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76683       };
76684     } catch (...) {
76685       {
76686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76687       };
76688     }
76689   }
76690
76691   jresult = result;
76692   return jresult;
76693 }
76694
76695
76696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76697   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76698   Dali::Toolkit::ItemId arg2 ;
76699   float arg3 ;
76700
76701   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76702   arg2 = (Dali::Toolkit::ItemId)jarg2;
76703   arg3 = (float)jarg3;
76704   {
76705     try {
76706       (arg1)->ScrollToItem(arg2,arg3);
76707     } catch (std::out_of_range& e) {
76708       {
76709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76710       };
76711     } catch (std::exception& e) {
76712       {
76713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76714       };
76715     } catch (Dali::DaliException e) {
76716       {
76717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76718       };
76719     } catch (...) {
76720       {
76721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76722       };
76723     }
76724   }
76725
76726 }
76727
76728
76729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76730   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76731   float arg2 ;
76732
76733   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76734   arg2 = (float)jarg2;
76735   {
76736     try {
76737       (arg1)->SetRefreshInterval(arg2);
76738     } catch (std::out_of_range& e) {
76739       {
76740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76741       };
76742     } catch (std::exception& e) {
76743       {
76744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76745       };
76746     } catch (Dali::DaliException e) {
76747       {
76748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76749       };
76750     } catch (...) {
76751       {
76752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76753       };
76754     }
76755   }
76756
76757 }
76758
76759
76760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76761   float jresult ;
76762   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76763   float result;
76764
76765   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76766   {
76767     try {
76768       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76769     } catch (std::out_of_range& e) {
76770       {
76771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76772       };
76773     } catch (std::exception& e) {
76774       {
76775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76776       };
76777     } catch (Dali::DaliException e) {
76778       {
76779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76780       };
76781     } catch (...) {
76782       {
76783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76784       };
76785     }
76786   }
76787
76788   jresult = result;
76789   return jresult;
76790 }
76791
76792
76793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76794   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76795
76796   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76797   {
76798     try {
76799       (arg1)->Refresh();
76800     } catch (std::out_of_range& e) {
76801       {
76802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76803       };
76804     } catch (std::exception& e) {
76805       {
76806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76807       };
76808     } catch (Dali::DaliException e) {
76809       {
76810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76811       };
76812     } catch (...) {
76813       {
76814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76815       };
76816     }
76817   }
76818
76819 }
76820
76821
76822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76823   void * jresult ;
76824   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76825   Dali::Toolkit::ItemId arg2 ;
76826   Dali::Actor result;
76827
76828   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76829   arg2 = (Dali::Toolkit::ItemId)jarg2;
76830   {
76831     try {
76832       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76833     } catch (std::out_of_range& e) {
76834       {
76835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76836       };
76837     } catch (std::exception& e) {
76838       {
76839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76840       };
76841     } catch (Dali::DaliException e) {
76842       {
76843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76844       };
76845     } catch (...) {
76846       {
76847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76848       };
76849     }
76850   }
76851
76852   jresult = new Dali::Actor((const Dali::Actor &)result);
76853   return jresult;
76854 }
76855
76856
76857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76858   unsigned int jresult ;
76859   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76860   Dali::Actor arg2 ;
76861   Dali::Actor *argp2 ;
76862   Dali::Toolkit::ItemId result;
76863
76864   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76865   argp2 = (Dali::Actor *)jarg2;
76866   if (!argp2) {
76867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76868     return 0;
76869   }
76870   arg2 = *argp2;
76871   {
76872     try {
76873       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76874     } catch (std::out_of_range& e) {
76875       {
76876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76877       };
76878     } catch (std::exception& e) {
76879       {
76880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76881       };
76882     } catch (Dali::DaliException e) {
76883       {
76884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76885       };
76886     } catch (...) {
76887       {
76888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76889       };
76890     }
76891   }
76892
76893   jresult = result;
76894   return jresult;
76895 }
76896
76897
76898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76899   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76900   Dali::Toolkit::Item arg2 ;
76901   float arg3 ;
76902   Dali::Toolkit::Item *argp2 ;
76903
76904   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76905   argp2 = (Dali::Toolkit::Item *)jarg2;
76906   if (!argp2) {
76907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76908     return ;
76909   }
76910   arg2 = *argp2;
76911   arg3 = (float)jarg3;
76912   {
76913     try {
76914       (arg1)->InsertItem(arg2,arg3);
76915     } catch (std::out_of_range& e) {
76916       {
76917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76918       };
76919     } catch (std::exception& e) {
76920       {
76921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76922       };
76923     } catch (Dali::DaliException e) {
76924       {
76925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76926       };
76927     } catch (...) {
76928       {
76929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76930       };
76931     }
76932   }
76933
76934 }
76935
76936
76937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76938   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76939   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76940   float arg3 ;
76941
76942   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76943   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76944   if (!arg2) {
76945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76946     return ;
76947   }
76948   arg3 = (float)jarg3;
76949   {
76950     try {
76951       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76952     } catch (std::out_of_range& e) {
76953       {
76954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76955       };
76956     } catch (std::exception& e) {
76957       {
76958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76959       };
76960     } catch (Dali::DaliException e) {
76961       {
76962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76963       };
76964     } catch (...) {
76965       {
76966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76967       };
76968     }
76969   }
76970
76971 }
76972
76973
76974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76975   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76976   Dali::Toolkit::ItemId arg2 ;
76977   float arg3 ;
76978
76979   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76980   arg2 = (Dali::Toolkit::ItemId)jarg2;
76981   arg3 = (float)jarg3;
76982   {
76983     try {
76984       (arg1)->RemoveItem(arg2,arg3);
76985     } catch (std::out_of_range& e) {
76986       {
76987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76988       };
76989     } catch (std::exception& e) {
76990       {
76991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76992       };
76993     } catch (Dali::DaliException e) {
76994       {
76995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76996       };
76997     } catch (...) {
76998       {
76999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77000       };
77001     }
77002   }
77003
77004 }
77005
77006
77007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77008   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77009   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77010   float arg3 ;
77011
77012   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77013   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77014   if (!arg2) {
77015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77016     return ;
77017   }
77018   arg3 = (float)jarg3;
77019   {
77020     try {
77021       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77022     } catch (std::out_of_range& e) {
77023       {
77024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77025       };
77026     } catch (std::exception& e) {
77027       {
77028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77029       };
77030     } catch (Dali::DaliException e) {
77031       {
77032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77033       };
77034     } catch (...) {
77035       {
77036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77037       };
77038     }
77039   }
77040
77041 }
77042
77043
77044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77045   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77046   Dali::Toolkit::Item arg2 ;
77047   float arg3 ;
77048   Dali::Toolkit::Item *argp2 ;
77049
77050   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77051   argp2 = (Dali::Toolkit::Item *)jarg2;
77052   if (!argp2) {
77053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77054     return ;
77055   }
77056   arg2 = *argp2;
77057   arg3 = (float)jarg3;
77058   {
77059     try {
77060       (arg1)->ReplaceItem(arg2,arg3);
77061     } catch (std::out_of_range& e) {
77062       {
77063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77064       };
77065     } catch (std::exception& e) {
77066       {
77067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77068       };
77069     } catch (Dali::DaliException e) {
77070       {
77071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77072       };
77073     } catch (...) {
77074       {
77075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77076       };
77077     }
77078   }
77079
77080 }
77081
77082
77083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77084   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77085   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77086   float arg3 ;
77087
77088   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77089   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77090   if (!arg2) {
77091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77092     return ;
77093   }
77094   arg3 = (float)jarg3;
77095   {
77096     try {
77097       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77098     } catch (std::out_of_range& e) {
77099       {
77100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77101       };
77102     } catch (std::exception& e) {
77103       {
77104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77105       };
77106     } catch (Dali::DaliException e) {
77107       {
77108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77109       };
77110     } catch (...) {
77111       {
77112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77113       };
77114     }
77115   }
77116
77117 }
77118
77119
77120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77121   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77122   Dali::Vector3 *arg2 = 0 ;
77123
77124   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77125   arg2 = (Dali::Vector3 *)jarg2;
77126   if (!arg2) {
77127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77128     return ;
77129   }
77130   {
77131     try {
77132       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77133     } catch (std::out_of_range& e) {
77134       {
77135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77136       };
77137     } catch (std::exception& e) {
77138       {
77139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77140       };
77141     } catch (Dali::DaliException e) {
77142       {
77143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77144       };
77145     } catch (...) {
77146       {
77147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77148       };
77149     }
77150   }
77151
77152 }
77153
77154
77155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77156   void * jresult ;
77157   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77158   Dali::Vector3 result;
77159
77160   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77161   {
77162     try {
77163       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77164     } catch (std::out_of_range& e) {
77165       {
77166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77167       };
77168     } catch (std::exception& e) {
77169       {
77170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77171       };
77172     } catch (Dali::DaliException e) {
77173       {
77174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77175       };
77176     } catch (...) {
77177       {
77178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77179       };
77180     }
77181   }
77182
77183   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77184   return jresult;
77185 }
77186
77187
77188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77189   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77190   Dali::Vector3 *arg2 = 0 ;
77191
77192   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77193   arg2 = (Dali::Vector3 *)jarg2;
77194   if (!arg2) {
77195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77196     return ;
77197   }
77198   {
77199     try {
77200       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77201     } catch (std::out_of_range& e) {
77202       {
77203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77204       };
77205     } catch (std::exception& e) {
77206       {
77207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77208       };
77209     } catch (Dali::DaliException e) {
77210       {
77211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77212       };
77213     } catch (...) {
77214       {
77215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77216       };
77217     }
77218   }
77219
77220 }
77221
77222
77223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77224   void * jresult ;
77225   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77226   Dali::Vector3 result;
77227
77228   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77229   {
77230     try {
77231       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77232     } catch (std::out_of_range& e) {
77233       {
77234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77235       };
77236     } catch (std::exception& e) {
77237       {
77238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77239       };
77240     } catch (Dali::DaliException e) {
77241       {
77242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77243       };
77244     } catch (...) {
77245       {
77246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77247       };
77248     }
77249   }
77250
77251   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77252   return jresult;
77253 }
77254
77255
77256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77257   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77258   Dali::Toolkit::ItemRange *arg2 = 0 ;
77259
77260   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77261   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77262   if (!arg2) {
77263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77264     return ;
77265   }
77266   {
77267     try {
77268       (arg1)->GetItemsRange(*arg2);
77269     } catch (std::out_of_range& e) {
77270       {
77271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77272       };
77273     } catch (std::exception& e) {
77274       {
77275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77276       };
77277     } catch (Dali::DaliException e) {
77278       {
77279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77280       };
77281     } catch (...) {
77282       {
77283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77284       };
77285     }
77286   }
77287
77288 }
77289
77290
77291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77292   void * jresult ;
77293   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77294   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77295
77296   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77297   {
77298     try {
77299       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77300     } catch (std::out_of_range& e) {
77301       {
77302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77303       };
77304     } catch (std::exception& e) {
77305       {
77306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77307       };
77308     } catch (Dali::DaliException e) {
77309       {
77310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77311       };
77312     } catch (...) {
77313       {
77314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77315       };
77316     }
77317   }
77318
77319   jresult = (void *)result;
77320   return jresult;
77321 }
77322
77323
77324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77325   Dali::Vector3 *arg1 = 0 ;
77326   PropertyInputContainer *arg2 = 0 ;
77327
77328   arg1 = (Dali::Vector3 *)jarg1;
77329   if (!arg1) {
77330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77331     return ;
77332   }
77333   arg2 = (PropertyInputContainer *)jarg2;
77334   if (!arg2) {
77335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77336     return ;
77337   }
77338   {
77339     try {
77340       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77341     } catch (std::out_of_range& e) {
77342       {
77343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77344       };
77345     } catch (std::exception& e) {
77346       {
77347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77348       };
77349     } catch (Dali::DaliException e) {
77350       {
77351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77352       };
77353     } catch (...) {
77354       {
77355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77356       };
77357     }
77358   }
77359
77360 }
77361
77362
77363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77364   Dali::Vector3 *arg1 = 0 ;
77365   PropertyInputContainer *arg2 = 0 ;
77366
77367   arg1 = (Dali::Vector3 *)jarg1;
77368   if (!arg1) {
77369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77370     return ;
77371   }
77372   arg2 = (PropertyInputContainer *)jarg2;
77373   if (!arg2) {
77374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77375     return ;
77376   }
77377   {
77378     try {
77379       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77380     } catch (std::out_of_range& e) {
77381       {
77382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77383       };
77384     } catch (std::exception& e) {
77385       {
77386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77387       };
77388     } catch (Dali::DaliException e) {
77389       {
77390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77391       };
77392     } catch (...) {
77393       {
77394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77395       };
77396     }
77397   }
77398
77399 }
77400
77401
77402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77403   void * jresult ;
77404   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77405
77406   {
77407     try {
77408       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77409     } catch (std::out_of_range& e) {
77410       {
77411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77412       };
77413     } catch (std::exception& e) {
77414       {
77415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77416       };
77417     } catch (Dali::DaliException e) {
77418       {
77419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77420       };
77421     } catch (...) {
77422       {
77423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77424       };
77425     }
77426   }
77427
77428   jresult = (void *)result;
77429   return jresult;
77430 }
77431
77432
77433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77434   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77435
77436   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77437   {
77438     try {
77439       delete arg1;
77440     } catch (std::out_of_range& e) {
77441       {
77442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77443       };
77444     } catch (std::exception& e) {
77445       {
77446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77447       };
77448     } catch (Dali::DaliException e) {
77449       {
77450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77451       };
77452     } catch (...) {
77453       {
77454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77455       };
77456     }
77457   }
77458
77459 }
77460
77461
77462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77463   void * jresult ;
77464   Dali::Path arg1 ;
77465   Dali::Vector3 *arg2 = 0 ;
77466   Dali::Property::Index arg3 ;
77467   Dali::Vector3 *arg4 = 0 ;
77468   unsigned int arg5 ;
77469   Dali::Path *argp1 ;
77470   Dali::Toolkit::ScrollViewPagePathEffect result;
77471
77472   argp1 = (Dali::Path *)jarg1;
77473   if (!argp1) {
77474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77475     return 0;
77476   }
77477   arg1 = *argp1;
77478   arg2 = (Dali::Vector3 *)jarg2;
77479   if (!arg2) {
77480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77481     return 0;
77482   }
77483   arg3 = (Dali::Property::Index)jarg3;
77484   arg4 = (Dali::Vector3 *)jarg4;
77485   if (!arg4) {
77486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77487     return 0;
77488   }
77489   arg5 = (unsigned int)jarg5;
77490   {
77491     try {
77492       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77493     } catch (std::out_of_range& e) {
77494       {
77495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77496       };
77497     } catch (std::exception& e) {
77498       {
77499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77500       };
77501     } catch (Dali::DaliException e) {
77502       {
77503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77504       };
77505     } catch (...) {
77506       {
77507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77508       };
77509     }
77510   }
77511
77512   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77513   return jresult;
77514 }
77515
77516
77517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77518   void * jresult ;
77519   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77520
77521   {
77522     try {
77523       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77524     } catch (std::out_of_range& e) {
77525       {
77526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77527       };
77528     } catch (std::exception& e) {
77529       {
77530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77531       };
77532     } catch (Dali::DaliException e) {
77533       {
77534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77535       };
77536     } catch (...) {
77537       {
77538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77539       };
77540     }
77541   }
77542
77543   jresult = (void *)result;
77544   return jresult;
77545 }
77546
77547
77548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77549   void * jresult ;
77550   Dali::BaseHandle arg1 ;
77551   Dali::BaseHandle *argp1 ;
77552   Dali::Toolkit::ScrollViewPagePathEffect result;
77553
77554   argp1 = (Dali::BaseHandle *)jarg1;
77555   if (!argp1) {
77556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77557     return 0;
77558   }
77559   arg1 = *argp1;
77560   {
77561     try {
77562       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77563     } catch (std::out_of_range& e) {
77564       {
77565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77566       };
77567     } catch (std::exception& e) {
77568       {
77569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77570       };
77571     } catch (Dali::DaliException e) {
77572       {
77573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77574       };
77575     } catch (...) {
77576       {
77577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77578       };
77579     }
77580   }
77581
77582   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77583   return jresult;
77584 }
77585
77586
77587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77588   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77589   Dali::Actor arg2 ;
77590   unsigned int arg3 ;
77591   Dali::Actor *argp2 ;
77592
77593   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77594   argp2 = (Dali::Actor *)jarg2;
77595   if (!argp2) {
77596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77597     return ;
77598   }
77599   arg2 = *argp2;
77600   arg3 = (unsigned int)jarg3;
77601   {
77602     try {
77603       (arg1)->ApplyToPage(arg2,arg3);
77604     } catch (std::out_of_range& e) {
77605       {
77606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77607       };
77608     } catch (std::exception& e) {
77609       {
77610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77611       };
77612     } catch (Dali::DaliException e) {
77613       {
77614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77615       };
77616     } catch (...) {
77617       {
77618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77619       };
77620     }
77621   }
77622
77623 }
77624
77625
77626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77627   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77628
77629   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77630   {
77631     try {
77632       delete arg1;
77633     } catch (std::out_of_range& e) {
77634       {
77635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77636       };
77637     } catch (std::exception& e) {
77638       {
77639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77640       };
77641     } catch (Dali::DaliException e) {
77642       {
77643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77644       };
77645     } catch (...) {
77646       {
77647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77648       };
77649     }
77650   }
77651
77652 }
77653
77654
77655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77656   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77657   Dali::Toolkit::ClampState arg2 ;
77658
77659   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77660   arg2 = (Dali::Toolkit::ClampState)jarg2;
77661   if (arg1) (arg1)->x = arg2;
77662 }
77663
77664
77665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77666   int jresult ;
77667   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77668   Dali::Toolkit::ClampState result;
77669
77670   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77671   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77672   jresult = (int)result;
77673   return jresult;
77674 }
77675
77676
77677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77678   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77679   Dali::Toolkit::ClampState arg2 ;
77680
77681   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77682   arg2 = (Dali::Toolkit::ClampState)jarg2;
77683   if (arg1) (arg1)->y = arg2;
77684 }
77685
77686
77687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77688   int jresult ;
77689   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77690   Dali::Toolkit::ClampState result;
77691
77692   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77693   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77694   jresult = (int)result;
77695   return jresult;
77696 }
77697
77698
77699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77700   void * jresult ;
77701   Dali::Toolkit::ClampState2D *result = 0 ;
77702
77703   {
77704     try {
77705       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77706     } catch (std::out_of_range& e) {
77707       {
77708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77709       };
77710     } catch (std::exception& e) {
77711       {
77712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77713       };
77714     } catch (Dali::DaliException e) {
77715       {
77716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77717       };
77718     } catch (...) {
77719       {
77720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77721       };
77722     }
77723   }
77724
77725   jresult = (void *)result;
77726   return jresult;
77727 }
77728
77729
77730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77731   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77732
77733   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77734   {
77735     try {
77736       delete arg1;
77737     } catch (std::out_of_range& e) {
77738       {
77739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77740       };
77741     } catch (std::exception& e) {
77742       {
77743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77744       };
77745     } catch (Dali::DaliException e) {
77746       {
77747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77748       };
77749     } catch (...) {
77750       {
77751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77752       };
77753     }
77754   }
77755
77756 }
77757
77758
77759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77760   void * jresult ;
77761   float arg1 ;
77762   float arg2 ;
77763   bool arg3 ;
77764   Dali::Toolkit::RulerDomain *result = 0 ;
77765
77766   arg1 = (float)jarg1;
77767   arg2 = (float)jarg2;
77768   arg3 = jarg3 ? true : false;
77769   {
77770     try {
77771       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77772     } catch (std::out_of_range& e) {
77773       {
77774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77775       };
77776     } catch (std::exception& e) {
77777       {
77778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77779       };
77780     } catch (Dali::DaliException e) {
77781       {
77782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77783       };
77784     } catch (...) {
77785       {
77786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77787       };
77788     }
77789   }
77790
77791   jresult = (void *)result;
77792   return jresult;
77793 }
77794
77795
77796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77797   void * jresult ;
77798   float arg1 ;
77799   float arg2 ;
77800   Dali::Toolkit::RulerDomain *result = 0 ;
77801
77802   arg1 = (float)jarg1;
77803   arg2 = (float)jarg2;
77804   {
77805     try {
77806       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77807     } catch (std::out_of_range& e) {
77808       {
77809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77810       };
77811     } catch (std::exception& e) {
77812       {
77813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77814       };
77815     } catch (Dali::DaliException e) {
77816       {
77817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77818       };
77819     } catch (...) {
77820       {
77821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77822       };
77823     }
77824   }
77825
77826   jresult = (void *)result;
77827   return jresult;
77828 }
77829
77830
77831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77832   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77833   float arg2 ;
77834
77835   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77836   arg2 = (float)jarg2;
77837   if (arg1) (arg1)->min = arg2;
77838 }
77839
77840
77841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77842   float jresult ;
77843   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77844   float result;
77845
77846   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77847   result = (float) ((arg1)->min);
77848   jresult = result;
77849   return jresult;
77850 }
77851
77852
77853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77854   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77855   float arg2 ;
77856
77857   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77858   arg2 = (float)jarg2;
77859   if (arg1) (arg1)->max = arg2;
77860 }
77861
77862
77863 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77864   float jresult ;
77865   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77866   float result;
77867
77868   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77869   result = (float) ((arg1)->max);
77870   jresult = result;
77871   return jresult;
77872 }
77873
77874
77875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77876   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77877   bool arg2 ;
77878
77879   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77880   arg2 = jarg2 ? true : false;
77881   if (arg1) (arg1)->enabled = arg2;
77882 }
77883
77884
77885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77886   unsigned int jresult ;
77887   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77888   bool result;
77889
77890   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77891   result = (bool) ((arg1)->enabled);
77892   jresult = result;
77893   return jresult;
77894 }
77895
77896
77897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77898   float jresult ;
77899   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77900   float arg2 ;
77901   float arg3 ;
77902   float arg4 ;
77903   float result;
77904
77905   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77906   arg2 = (float)jarg2;
77907   arg3 = (float)jarg3;
77908   arg4 = (float)jarg4;
77909   {
77910     try {
77911       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77912     } catch (std::out_of_range& e) {
77913       {
77914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77915       };
77916     } catch (std::exception& e) {
77917       {
77918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77919       };
77920     } catch (Dali::DaliException e) {
77921       {
77922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77923       };
77924     } catch (...) {
77925       {
77926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77927       };
77928     }
77929   }
77930
77931   jresult = result;
77932   return jresult;
77933 }
77934
77935
77936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77937   float jresult ;
77938   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77939   float arg2 ;
77940   float arg3 ;
77941   float result;
77942
77943   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77944   arg2 = (float)jarg2;
77945   arg3 = (float)jarg3;
77946   {
77947     try {
77948       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77949     } catch (std::out_of_range& e) {
77950       {
77951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77952       };
77953     } catch (std::exception& e) {
77954       {
77955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77956       };
77957     } catch (Dali::DaliException e) {
77958       {
77959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77960       };
77961     } catch (...) {
77962       {
77963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77964       };
77965     }
77966   }
77967
77968   jresult = result;
77969   return jresult;
77970 }
77971
77972
77973 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77974   float jresult ;
77975   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77976   float arg2 ;
77977   float result;
77978
77979   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77980   arg2 = (float)jarg2;
77981   {
77982     try {
77983       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77984     } catch (std::out_of_range& e) {
77985       {
77986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77987       };
77988     } catch (std::exception& e) {
77989       {
77990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77991       };
77992     } catch (Dali::DaliException e) {
77993       {
77994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77995       };
77996     } catch (...) {
77997       {
77998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77999       };
78000     }
78001   }
78002
78003   jresult = result;
78004   return jresult;
78005 }
78006
78007
78008 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78009   float jresult ;
78010   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78011   float arg2 ;
78012   float arg3 ;
78013   float arg4 ;
78014   Dali::Toolkit::ClampState *arg5 = 0 ;
78015   float result;
78016
78017   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78018   arg2 = (float)jarg2;
78019   arg3 = (float)jarg3;
78020   arg4 = (float)jarg4;
78021   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78022   if (!arg5) {
78023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78024     return 0;
78025   }
78026   {
78027     try {
78028       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78029     } catch (std::out_of_range& e) {
78030       {
78031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78032       };
78033     } catch (std::exception& e) {
78034       {
78035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78036       };
78037     } catch (Dali::DaliException e) {
78038       {
78039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78040       };
78041     } catch (...) {
78042       {
78043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78044       };
78045     }
78046   }
78047
78048   jresult = result;
78049   return jresult;
78050 }
78051
78052
78053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78054   float jresult ;
78055   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78056   float result;
78057
78058   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78059   {
78060     try {
78061       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78062     } catch (std::out_of_range& e) {
78063       {
78064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78065       };
78066     } catch (std::exception& e) {
78067       {
78068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78069       };
78070     } catch (Dali::DaliException e) {
78071       {
78072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78073       };
78074     } catch (...) {
78075       {
78076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78077       };
78078     }
78079   }
78080
78081   jresult = result;
78082   return jresult;
78083 }
78084
78085
78086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78087   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78088
78089   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78090   {
78091     try {
78092       delete arg1;
78093     } catch (std::out_of_range& e) {
78094       {
78095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78096       };
78097     } catch (std::exception& e) {
78098       {
78099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78100       };
78101     } catch (Dali::DaliException e) {
78102       {
78103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78104       };
78105     } catch (...) {
78106       {
78107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78108       };
78109     }
78110   }
78111
78112 }
78113
78114
78115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78116   float jresult ;
78117   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78118   float arg2 ;
78119   float arg3 ;
78120   float result;
78121
78122   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78123   arg2 = (float)jarg2;
78124   arg3 = (float)jarg3;
78125   {
78126     try {
78127       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78128     } catch (std::out_of_range& e) {
78129       {
78130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78131       };
78132     } catch (std::exception& e) {
78133       {
78134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78135       };
78136     } catch (Dali::DaliException e) {
78137       {
78138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78139       };
78140     } catch (...) {
78141       {
78142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78143       };
78144     }
78145   }
78146
78147   jresult = result;
78148   return jresult;
78149 }
78150
78151
78152 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78153   float jresult ;
78154   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78155   float arg2 ;
78156   float result;
78157
78158   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78159   arg2 = (float)jarg2;
78160   {
78161     try {
78162       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78163     } catch (std::out_of_range& e) {
78164       {
78165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78166       };
78167     } catch (std::exception& e) {
78168       {
78169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78170       };
78171     } catch (Dali::DaliException e) {
78172       {
78173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78174       };
78175     } catch (...) {
78176       {
78177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78178       };
78179     }
78180   }
78181
78182   jresult = result;
78183   return jresult;
78184 }
78185
78186
78187 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78188   float jresult ;
78189   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78190   unsigned int arg2 ;
78191   unsigned int *arg3 = 0 ;
78192   bool arg4 ;
78193   float result;
78194
78195   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78196   arg2 = (unsigned int)jarg2;
78197   arg3 = (unsigned int *)jarg3;
78198   arg4 = jarg4 ? true : false;
78199   {
78200     try {
78201       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78202     } catch (std::out_of_range& e) {
78203       {
78204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78205       };
78206     } catch (std::exception& e) {
78207       {
78208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78209       };
78210     } catch (Dali::DaliException e) {
78211       {
78212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78213       };
78214     } catch (...) {
78215       {
78216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78217       };
78218     }
78219   }
78220
78221   jresult = result;
78222   return jresult;
78223 }
78224
78225
78226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78227   unsigned int jresult ;
78228   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78229   float arg2 ;
78230   bool arg3 ;
78231   unsigned int result;
78232
78233   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78234   arg2 = (float)jarg2;
78235   arg3 = jarg3 ? true : false;
78236   {
78237     try {
78238       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78239     } catch (std::out_of_range& e) {
78240       {
78241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78242       };
78243     } catch (std::exception& e) {
78244       {
78245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78246       };
78247     } catch (Dali::DaliException e) {
78248       {
78249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78250       };
78251     } catch (...) {
78252       {
78253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78254       };
78255     }
78256   }
78257
78258   jresult = result;
78259   return jresult;
78260 }
78261
78262
78263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78264   unsigned int jresult ;
78265   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78266   unsigned int result;
78267
78268   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78269   {
78270     try {
78271       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78272     } catch (std::out_of_range& e) {
78273       {
78274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78275       };
78276     } catch (std::exception& e) {
78277       {
78278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78279       };
78280     } catch (Dali::DaliException e) {
78281       {
78282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78283       };
78284     } catch (...) {
78285       {
78286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78287       };
78288     }
78289   }
78290
78291   jresult = result;
78292   return jresult;
78293 }
78294
78295
78296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78297   int jresult ;
78298   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78299   Dali::Toolkit::Ruler::RulerType result;
78300
78301   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78302   {
78303     try {
78304       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78305     } catch (std::out_of_range& e) {
78306       {
78307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78308       };
78309     } catch (std::exception& e) {
78310       {
78311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78312       };
78313     } catch (Dali::DaliException e) {
78314       {
78315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78316       };
78317     } catch (...) {
78318       {
78319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78320       };
78321     }
78322   }
78323
78324   jresult = (int)result;
78325   return jresult;
78326 }
78327
78328
78329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78330   unsigned int jresult ;
78331   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78332   bool result;
78333
78334   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78335   {
78336     try {
78337       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78338     } catch (std::out_of_range& e) {
78339       {
78340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78341       };
78342     } catch (std::exception& e) {
78343       {
78344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78345       };
78346     } catch (Dali::DaliException e) {
78347       {
78348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78349       };
78350     } catch (...) {
78351       {
78352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78353       };
78354     }
78355   }
78356
78357   jresult = result;
78358   return jresult;
78359 }
78360
78361
78362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78363   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78364
78365   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78366   {
78367     try {
78368       (arg1)->Enable();
78369     } catch (std::out_of_range& e) {
78370       {
78371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78372       };
78373     } catch (std::exception& e) {
78374       {
78375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78376       };
78377     } catch (Dali::DaliException e) {
78378       {
78379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78380       };
78381     } catch (...) {
78382       {
78383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78384       };
78385     }
78386   }
78387
78388 }
78389
78390
78391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78392   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78393
78394   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78395   {
78396     try {
78397       (arg1)->Disable();
78398     } catch (std::out_of_range& e) {
78399       {
78400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78401       };
78402     } catch (std::exception& e) {
78403       {
78404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78405       };
78406     } catch (Dali::DaliException e) {
78407       {
78408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78409       };
78410     } catch (...) {
78411       {
78412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78413       };
78414     }
78415   }
78416
78417 }
78418
78419
78420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78421   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78422   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78423   Dali::Toolkit::RulerDomain *argp2 ;
78424
78425   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78426   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78427   if (!argp2) {
78428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78429     return ;
78430   }
78431   arg2 = *argp2;
78432   {
78433     try {
78434       (arg1)->SetDomain(arg2);
78435     } catch (std::out_of_range& e) {
78436       {
78437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78438       };
78439     } catch (std::exception& e) {
78440       {
78441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78442       };
78443     } catch (Dali::DaliException e) {
78444       {
78445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78446       };
78447     } catch (...) {
78448       {
78449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78450       };
78451     }
78452   }
78453
78454 }
78455
78456
78457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78458   void * jresult ;
78459   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78460   Dali::Toolkit::RulerDomain *result = 0 ;
78461
78462   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78463   {
78464     try {
78465       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78466     } catch (std::out_of_range& e) {
78467       {
78468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78469       };
78470     } catch (std::exception& e) {
78471       {
78472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78473       };
78474     } catch (Dali::DaliException e) {
78475       {
78476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78477       };
78478     } catch (...) {
78479       {
78480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78481       };
78482     }
78483   }
78484
78485   jresult = (void *)result;
78486   return jresult;
78487 }
78488
78489
78490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78491   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78492
78493   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78494   {
78495     try {
78496       (arg1)->DisableDomain();
78497     } catch (std::out_of_range& e) {
78498       {
78499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78500       };
78501     } catch (std::exception& e) {
78502       {
78503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78504       };
78505     } catch (Dali::DaliException e) {
78506       {
78507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78508       };
78509     } catch (...) {
78510       {
78511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78512       };
78513     }
78514   }
78515
78516 }
78517
78518
78519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78520   float jresult ;
78521   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78522   float arg2 ;
78523   float arg3 ;
78524   float arg4 ;
78525   float result;
78526
78527   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78528   arg2 = (float)jarg2;
78529   arg3 = (float)jarg3;
78530   arg4 = (float)jarg4;
78531   {
78532     try {
78533       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78534     } catch (std::out_of_range& e) {
78535       {
78536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78537       };
78538     } catch (std::exception& e) {
78539       {
78540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78541       };
78542     } catch (Dali::DaliException e) {
78543       {
78544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78545       };
78546     } catch (...) {
78547       {
78548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78549       };
78550     }
78551   }
78552
78553   jresult = result;
78554   return jresult;
78555 }
78556
78557
78558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78559   float jresult ;
78560   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78561   float arg2 ;
78562   float arg3 ;
78563   float result;
78564
78565   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78566   arg2 = (float)jarg2;
78567   arg3 = (float)jarg3;
78568   {
78569     try {
78570       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78571     } catch (std::out_of_range& e) {
78572       {
78573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78574       };
78575     } catch (std::exception& e) {
78576       {
78577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78578       };
78579     } catch (Dali::DaliException e) {
78580       {
78581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78582       };
78583     } catch (...) {
78584       {
78585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78586       };
78587     }
78588   }
78589
78590   jresult = result;
78591   return jresult;
78592 }
78593
78594
78595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78596   float jresult ;
78597   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78598   float arg2 ;
78599   float result;
78600
78601   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78602   arg2 = (float)jarg2;
78603   {
78604     try {
78605       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78606     } catch (std::out_of_range& e) {
78607       {
78608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78609       };
78610     } catch (std::exception& e) {
78611       {
78612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78613       };
78614     } catch (Dali::DaliException e) {
78615       {
78616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78617       };
78618     } catch (...) {
78619       {
78620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78621       };
78622     }
78623   }
78624
78625   jresult = result;
78626   return jresult;
78627 }
78628
78629
78630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78631   float jresult ;
78632   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78633   float arg2 ;
78634   float arg3 ;
78635   float arg4 ;
78636   Dali::Toolkit::ClampState *arg5 = 0 ;
78637   float result;
78638
78639   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78640   arg2 = (float)jarg2;
78641   arg3 = (float)jarg3;
78642   arg4 = (float)jarg4;
78643   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78644   if (!arg5) {
78645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78646     return 0;
78647   }
78648   {
78649     try {
78650       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78651     } catch (std::out_of_range& e) {
78652       {
78653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78654       };
78655     } catch (std::exception& e) {
78656       {
78657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78658       };
78659     } catch (Dali::DaliException e) {
78660       {
78661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78662       };
78663     } catch (...) {
78664       {
78665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78666       };
78667     }
78668   }
78669
78670   jresult = result;
78671   return jresult;
78672 }
78673
78674
78675 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78676   float jresult ;
78677   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78678   float arg2 ;
78679   float arg3 ;
78680   float arg4 ;
78681   float arg5 ;
78682   float result;
78683
78684   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78685   arg2 = (float)jarg2;
78686   arg3 = (float)jarg3;
78687   arg4 = (float)jarg4;
78688   arg5 = (float)jarg5;
78689   {
78690     try {
78691       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78692     } catch (std::out_of_range& e) {
78693       {
78694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78695       };
78696     } catch (std::exception& e) {
78697       {
78698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78699       };
78700     } catch (Dali::DaliException e) {
78701       {
78702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78703       };
78704     } catch (...) {
78705       {
78706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78707       };
78708     }
78709   }
78710
78711   jresult = result;
78712   return jresult;
78713 }
78714
78715
78716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78717   float jresult ;
78718   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78719   float arg2 ;
78720   float arg3 ;
78721   float arg4 ;
78722   float result;
78723
78724   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78725   arg2 = (float)jarg2;
78726   arg3 = (float)jarg3;
78727   arg4 = (float)jarg4;
78728   {
78729     try {
78730       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78731     } catch (std::out_of_range& e) {
78732       {
78733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78734       };
78735     } catch (std::exception& e) {
78736       {
78737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78738       };
78739     } catch (Dali::DaliException e) {
78740       {
78741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78742       };
78743     } catch (...) {
78744       {
78745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78746       };
78747     }
78748   }
78749
78750   jresult = result;
78751   return jresult;
78752 }
78753
78754
78755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78756   float jresult ;
78757   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78758   float arg2 ;
78759   float arg3 ;
78760   float result;
78761
78762   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78763   arg2 = (float)jarg2;
78764   arg3 = (float)jarg3;
78765   {
78766     try {
78767       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78768     } catch (std::out_of_range& e) {
78769       {
78770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78771       };
78772     } catch (std::exception& e) {
78773       {
78774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78775       };
78776     } catch (Dali::DaliException e) {
78777       {
78778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78779       };
78780     } catch (...) {
78781       {
78782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78783       };
78784     }
78785   }
78786
78787   jresult = result;
78788   return jresult;
78789 }
78790
78791
78792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78793   float jresult ;
78794   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78795   float arg2 ;
78796   float result;
78797
78798   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78799   arg2 = (float)jarg2;
78800   {
78801     try {
78802       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78803     } catch (std::out_of_range& e) {
78804       {
78805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78806       };
78807     } catch (std::exception& e) {
78808       {
78809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78810       };
78811     } catch (Dali::DaliException e) {
78812       {
78813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78814       };
78815     } catch (...) {
78816       {
78817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78818       };
78819     }
78820   }
78821
78822   jresult = result;
78823   return jresult;
78824 }
78825
78826
78827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78828   float jresult ;
78829   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78830   float arg2 ;
78831   float arg3 ;
78832   float arg4 ;
78833   float arg5 ;
78834   Dali::Toolkit::ClampState *arg6 = 0 ;
78835   float result;
78836
78837   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78838   arg2 = (float)jarg2;
78839   arg3 = (float)jarg3;
78840   arg4 = (float)jarg4;
78841   arg5 = (float)jarg5;
78842   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78843   if (!arg6) {
78844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78845     return 0;
78846   }
78847   {
78848     try {
78849       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78850     } catch (std::out_of_range& e) {
78851       {
78852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78853       };
78854     } catch (std::exception& e) {
78855       {
78856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78857       };
78858     } catch (Dali::DaliException e) {
78859       {
78860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78861       };
78862     } catch (...) {
78863       {
78864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78865       };
78866     }
78867   }
78868
78869   jresult = result;
78870   return jresult;
78871 }
78872
78873
78874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78875   void * jresult ;
78876   Dali::Toolkit::DefaultRuler *result = 0 ;
78877
78878   {
78879     try {
78880       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78881     } catch (std::out_of_range& e) {
78882       {
78883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78884       };
78885     } catch (std::exception& e) {
78886       {
78887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78888       };
78889     } catch (Dali::DaliException e) {
78890       {
78891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78892       };
78893     } catch (...) {
78894       {
78895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78896       };
78897     }
78898   }
78899
78900   jresult = (void *)result;
78901   return jresult;
78902 }
78903
78904
78905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78906   float jresult ;
78907   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78908   float arg2 ;
78909   float arg3 ;
78910   float result;
78911
78912   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78913   arg2 = (float)jarg2;
78914   arg3 = (float)jarg3;
78915   {
78916     try {
78917       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78918     } catch (std::out_of_range& e) {
78919       {
78920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78921       };
78922     } catch (std::exception& e) {
78923       {
78924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78925       };
78926     } catch (Dali::DaliException e) {
78927       {
78928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78929       };
78930     } catch (...) {
78931       {
78932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78933       };
78934     }
78935   }
78936
78937   jresult = result;
78938   return jresult;
78939 }
78940
78941
78942 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78943   float jresult ;
78944   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78945   unsigned int arg2 ;
78946   unsigned int *arg3 = 0 ;
78947   bool arg4 ;
78948   float result;
78949
78950   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78951   arg2 = (unsigned int)jarg2;
78952   arg3 = (unsigned int *)jarg3;
78953   arg4 = jarg4 ? true : false;
78954   {
78955     try {
78956       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78957     } catch (std::out_of_range& e) {
78958       {
78959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78960       };
78961     } catch (std::exception& e) {
78962       {
78963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78964       };
78965     } catch (Dali::DaliException e) {
78966       {
78967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78968       };
78969     } catch (...) {
78970       {
78971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78972       };
78973     }
78974   }
78975
78976   jresult = result;
78977   return jresult;
78978 }
78979
78980
78981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78982   unsigned int jresult ;
78983   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78984   float arg2 ;
78985   bool arg3 ;
78986   unsigned int result;
78987
78988   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78989   arg2 = (float)jarg2;
78990   arg3 = jarg3 ? true : false;
78991   {
78992     try {
78993       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78994     } catch (std::out_of_range& e) {
78995       {
78996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78997       };
78998     } catch (std::exception& e) {
78999       {
79000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79001       };
79002     } catch (Dali::DaliException e) {
79003       {
79004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79005       };
79006     } catch (...) {
79007       {
79008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79009       };
79010     }
79011   }
79012
79013   jresult = result;
79014   return jresult;
79015 }
79016
79017
79018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79019   unsigned int jresult ;
79020   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79021   unsigned int result;
79022
79023   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79024   {
79025     try {
79026       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79027     } catch (std::out_of_range& e) {
79028       {
79029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79030       };
79031     } catch (std::exception& e) {
79032       {
79033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79034       };
79035     } catch (Dali::DaliException e) {
79036       {
79037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79038       };
79039     } catch (...) {
79040       {
79041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79042       };
79043     }
79044   }
79045
79046   jresult = result;
79047   return jresult;
79048 }
79049
79050
79051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79052   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79053
79054   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79055   {
79056     try {
79057       delete arg1;
79058     } catch (std::out_of_range& e) {
79059       {
79060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79061       };
79062     } catch (std::exception& e) {
79063       {
79064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79065       };
79066     } catch (Dali::DaliException e) {
79067       {
79068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79069       };
79070     } catch (...) {
79071       {
79072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79073       };
79074     }
79075   }
79076
79077 }
79078
79079
79080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79081   void * jresult ;
79082   float arg1 ;
79083   Dali::Toolkit::FixedRuler *result = 0 ;
79084
79085   arg1 = (float)jarg1;
79086   {
79087     try {
79088       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79089     } catch (std::out_of_range& e) {
79090       {
79091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79092       };
79093     } catch (std::exception& e) {
79094       {
79095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79096       };
79097     } catch (Dali::DaliException e) {
79098       {
79099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79100       };
79101     } catch (...) {
79102       {
79103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79104       };
79105     }
79106   }
79107
79108   jresult = (void *)result;
79109   return jresult;
79110 }
79111
79112
79113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79114   void * jresult ;
79115   Dali::Toolkit::FixedRuler *result = 0 ;
79116
79117   {
79118     try {
79119       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79120     } catch (std::out_of_range& e) {
79121       {
79122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79123       };
79124     } catch (std::exception& e) {
79125       {
79126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79127       };
79128     } catch (Dali::DaliException e) {
79129       {
79130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79131       };
79132     } catch (...) {
79133       {
79134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79135       };
79136     }
79137   }
79138
79139   jresult = (void *)result;
79140   return jresult;
79141 }
79142
79143
79144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79145   float jresult ;
79146   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79147   float arg2 ;
79148   float arg3 ;
79149   float result;
79150
79151   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79152   arg2 = (float)jarg2;
79153   arg3 = (float)jarg3;
79154   {
79155     try {
79156       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79157     } catch (std::out_of_range& e) {
79158       {
79159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79160       };
79161     } catch (std::exception& e) {
79162       {
79163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79164       };
79165     } catch (Dali::DaliException e) {
79166       {
79167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79168       };
79169     } catch (...) {
79170       {
79171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79172       };
79173     }
79174   }
79175
79176   jresult = result;
79177   return jresult;
79178 }
79179
79180
79181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79182   float jresult ;
79183   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79184   unsigned int arg2 ;
79185   unsigned int *arg3 = 0 ;
79186   bool arg4 ;
79187   float result;
79188
79189   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79190   arg2 = (unsigned int)jarg2;
79191   arg3 = (unsigned int *)jarg3;
79192   arg4 = jarg4 ? true : false;
79193   {
79194     try {
79195       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79196     } catch (std::out_of_range& e) {
79197       {
79198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79199       };
79200     } catch (std::exception& e) {
79201       {
79202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79203       };
79204     } catch (Dali::DaliException e) {
79205       {
79206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79207       };
79208     } catch (...) {
79209       {
79210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79211       };
79212     }
79213   }
79214
79215   jresult = result;
79216   return jresult;
79217 }
79218
79219
79220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79221   unsigned int jresult ;
79222   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79223   float arg2 ;
79224   bool arg3 ;
79225   unsigned int result;
79226
79227   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79228   arg2 = (float)jarg2;
79229   arg3 = jarg3 ? true : false;
79230   {
79231     try {
79232       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79233     } catch (std::out_of_range& e) {
79234       {
79235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79236       };
79237     } catch (std::exception& e) {
79238       {
79239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79240       };
79241     } catch (Dali::DaliException e) {
79242       {
79243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79244       };
79245     } catch (...) {
79246       {
79247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79248       };
79249     }
79250   }
79251
79252   jresult = result;
79253   return jresult;
79254 }
79255
79256
79257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79258   unsigned int jresult ;
79259   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79260   unsigned int result;
79261
79262   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79263   {
79264     try {
79265       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79266     } catch (std::out_of_range& e) {
79267       {
79268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79269       };
79270     } catch (std::exception& e) {
79271       {
79272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79273       };
79274     } catch (Dali::DaliException e) {
79275       {
79276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79277       };
79278     } catch (...) {
79279       {
79280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79281       };
79282     }
79283   }
79284
79285   jresult = result;
79286   return jresult;
79287 }
79288
79289
79290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79291   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79292
79293   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79294   {
79295     try {
79296       delete arg1;
79297     } catch (std::out_of_range& e) {
79298       {
79299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79300       };
79301     } catch (std::exception& e) {
79302       {
79303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79304       };
79305     } catch (Dali::DaliException e) {
79306       {
79307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79308       };
79309     } catch (...) {
79310       {
79311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79312       };
79313     }
79314   }
79315
79316 }
79317
79318
79319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79320   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79321   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79322
79323   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79324   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79325   if (arg1) (arg1)->scale = *arg2;
79326 }
79327
79328
79329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79330   void * jresult ;
79331   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79332   Dali::Toolkit::ClampState2D *result = 0 ;
79333
79334   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79335   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79336   jresult = (void *)result;
79337   return jresult;
79338 }
79339
79340
79341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79342   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79343   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79344
79345   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79346   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79347   if (arg1) (arg1)->position = *arg2;
79348 }
79349
79350
79351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79352   void * jresult ;
79353   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79354   Dali::Toolkit::ClampState2D *result = 0 ;
79355
79356   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79357   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79358   jresult = (void *)result;
79359   return jresult;
79360 }
79361
79362
79363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79364   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79365   Dali::Toolkit::ClampState arg2 ;
79366
79367   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79368   arg2 = (Dali::Toolkit::ClampState)jarg2;
79369   if (arg1) (arg1)->rotation = arg2;
79370 }
79371
79372
79373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79374   int jresult ;
79375   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79376   Dali::Toolkit::ClampState result;
79377
79378   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79379   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79380   jresult = (int)result;
79381   return jresult;
79382 }
79383
79384
79385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79386   void * jresult ;
79387   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79388
79389   {
79390     try {
79391       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79392     } catch (std::out_of_range& e) {
79393       {
79394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79395       };
79396     } catch (std::exception& e) {
79397       {
79398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79399       };
79400     } catch (Dali::DaliException e) {
79401       {
79402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79403       };
79404     } catch (...) {
79405       {
79406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79407       };
79408     }
79409   }
79410
79411   jresult = (void *)result;
79412   return jresult;
79413 }
79414
79415
79416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79417   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79418
79419   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79420   {
79421     try {
79422       delete arg1;
79423     } catch (std::out_of_range& e) {
79424       {
79425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79426       };
79427     } catch (std::exception& e) {
79428       {
79429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79430       };
79431     } catch (Dali::DaliException e) {
79432       {
79433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79434       };
79435     } catch (...) {
79436       {
79437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79438       };
79439     }
79440   }
79441
79442 }
79443
79444
79445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79446   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79447   Dali::Toolkit::SnapType arg2 ;
79448
79449   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79450   arg2 = (Dali::Toolkit::SnapType)jarg2;
79451   if (arg1) (arg1)->type = arg2;
79452 }
79453
79454
79455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79456   int jresult ;
79457   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79458   Dali::Toolkit::SnapType result;
79459
79460   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79461   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79462   jresult = (int)result;
79463   return jresult;
79464 }
79465
79466
79467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79468   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79469   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79470
79471   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79472   arg2 = (Dali::Vector2 *)jarg2;
79473   if (arg1) (arg1)->position = *arg2;
79474 }
79475
79476
79477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79478   void * jresult ;
79479   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79480   Dali::Vector2 *result = 0 ;
79481
79482   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79483   result = (Dali::Vector2 *)& ((arg1)->position);
79484   jresult = (void *)result;
79485   return jresult;
79486 }
79487
79488
79489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79490   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79491   float arg2 ;
79492
79493   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79494   arg2 = (float)jarg2;
79495   if (arg1) (arg1)->duration = arg2;
79496 }
79497
79498
79499 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79500   float jresult ;
79501   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79502   float result;
79503
79504   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79505   result = (float) ((arg1)->duration);
79506   jresult = result;
79507   return jresult;
79508 }
79509
79510
79511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79512   void * jresult ;
79513   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79514
79515   {
79516     try {
79517       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79518     } catch (std::out_of_range& e) {
79519       {
79520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79521       };
79522     } catch (std::exception& e) {
79523       {
79524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79525       };
79526     } catch (Dali::DaliException e) {
79527       {
79528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79529       };
79530     } catch (...) {
79531       {
79532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79533       };
79534     }
79535   }
79536
79537   jresult = (void *)result;
79538   return jresult;
79539 }
79540
79541
79542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79543   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79544
79545   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79546   {
79547     try {
79548       delete arg1;
79549     } catch (std::out_of_range& e) {
79550       {
79551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79552       };
79553     } catch (std::exception& e) {
79554       {
79555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79556       };
79557     } catch (Dali::DaliException e) {
79558       {
79559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79560       };
79561     } catch (...) {
79562       {
79563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79564       };
79565     }
79566   }
79567
79568 }
79569
79570
79571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79572   int jresult ;
79573   int result;
79574
79575   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79576   jresult = (int)result;
79577   return jresult;
79578 }
79579
79580
79581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79582   int jresult ;
79583   int result;
79584
79585   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79586   jresult = (int)result;
79587   return jresult;
79588 }
79589
79590
79591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79592   int jresult ;
79593   int result;
79594
79595   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79596   jresult = (int)result;
79597   return jresult;
79598 }
79599
79600
79601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79602   int jresult ;
79603   int result;
79604
79605   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79606   jresult = (int)result;
79607   return jresult;
79608 }
79609
79610
79611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79612   int jresult ;
79613   int result;
79614
79615   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79616   jresult = (int)result;
79617   return jresult;
79618 }
79619
79620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79621   int jresult ;
79622   int result;
79623
79624   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79625   jresult = (int)result;
79626   return jresult;
79627 }
79628
79629
79630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79631   int jresult ;
79632   int result;
79633
79634   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79635   jresult = (int)result;
79636   return jresult;
79637 }
79638
79639
79640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79641   int jresult ;
79642   int result;
79643
79644   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79645   jresult = (int)result;
79646   return jresult;
79647 }
79648
79649
79650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79651   int jresult ;
79652   int result;
79653
79654   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79655   jresult = (int)result;
79656   return jresult;
79657 }
79658
79659
79660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79661   int jresult ;
79662   int result;
79663
79664   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79665   jresult = (int)result;
79666   return jresult;
79667 }
79668
79669
79670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79671   int jresult ;
79672   int result;
79673
79674   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79675   jresult = (int)result;
79676   return jresult;
79677 }
79678
79679
79680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79681   int jresult ;
79682   int result;
79683
79684   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79685   jresult = (int)result;
79686   return jresult;
79687 }
79688
79689
79690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79691   int jresult ;
79692   int result;
79693
79694   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79695   jresult = (int)result;
79696   return jresult;
79697 }
79698
79699
79700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79701   int jresult ;
79702   int result;
79703
79704   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79705   jresult = (int)result;
79706   return jresult;
79707 }
79708
79709
79710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79711   int jresult ;
79712   int result;
79713
79714   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79715   jresult = (int)result;
79716   return jresult;
79717 }
79718
79719
79720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79721   int jresult ;
79722   int result;
79723
79724   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79725   jresult = (int)result;
79726   return jresult;
79727 }
79728
79729
79730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79731   int jresult ;
79732   int result;
79733
79734   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79735   jresult = (int)result;
79736   return jresult;
79737 }
79738
79739
79740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79741   int jresult ;
79742   int result;
79743
79744   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79745   jresult = (int)result;
79746   return jresult;
79747 }
79748
79749
79750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79751   int jresult ;
79752   int result;
79753
79754   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79755   jresult = (int)result;
79756   return jresult;
79757 }
79758
79759
79760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79761   int jresult ;
79762   int result;
79763
79764   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79765   jresult = (int)result;
79766   return jresult;
79767 }
79768
79769
79770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79771   int jresult ;
79772   int result;
79773
79774   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79775   jresult = (int)result;
79776   return jresult;
79777 }
79778
79779
79780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79781   int jresult ;
79782   int result;
79783
79784   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79785   jresult = (int)result;
79786   return jresult;
79787 }
79788
79789
79790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79791   int jresult ;
79792   int result;
79793
79794   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79795   jresult = (int)result;
79796   return jresult;
79797 }
79798
79799
79800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79801   int jresult ;
79802   int result;
79803
79804   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79805   jresult = (int)result;
79806   return jresult;
79807 }
79808
79809
79810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79811   int jresult ;
79812   int result;
79813
79814   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79815   jresult = (int)result;
79816   return jresult;
79817 }
79818
79819
79820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79821   int jresult ;
79822   int result;
79823
79824   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79825   jresult = (int)result;
79826   return jresult;
79827 }
79828
79829
79830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79831   void * jresult ;
79832   Dali::Toolkit::ScrollView::Property *result = 0 ;
79833
79834   {
79835     try {
79836       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79837     } catch (std::out_of_range& e) {
79838       {
79839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79840       };
79841     } catch (std::exception& e) {
79842       {
79843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79844       };
79845     } catch (Dali::DaliException e) {
79846       {
79847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79848       };
79849     } catch (...) {
79850       {
79851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79852       };
79853     }
79854   }
79855
79856   jresult = (void *)result;
79857   return jresult;
79858 }
79859
79860
79861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79862   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79863
79864   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79865   {
79866     try {
79867       delete arg1;
79868     } catch (std::out_of_range& e) {
79869       {
79870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79871       };
79872     } catch (std::exception& e) {
79873       {
79874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79875       };
79876     } catch (Dali::DaliException e) {
79877       {
79878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79879       };
79880     } catch (...) {
79881       {
79882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79883       };
79884     }
79885   }
79886
79887 }
79888
79889
79890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79891   void * jresult ;
79892   Dali::Toolkit::ScrollView *result = 0 ;
79893
79894   {
79895     try {
79896       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79897     } catch (std::out_of_range& e) {
79898       {
79899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79900       };
79901     } catch (std::exception& e) {
79902       {
79903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79904       };
79905     } catch (Dali::DaliException e) {
79906       {
79907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79908       };
79909     } catch (...) {
79910       {
79911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79912       };
79913     }
79914   }
79915
79916   jresult = (void *)result;
79917   return jresult;
79918 }
79919
79920
79921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79922   void * jresult ;
79923   Dali::Toolkit::ScrollView *arg1 = 0 ;
79924   Dali::Toolkit::ScrollView *result = 0 ;
79925
79926   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79927   if (!arg1) {
79928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79929     return 0;
79930   }
79931   {
79932     try {
79933       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79934     } catch (std::out_of_range& e) {
79935       {
79936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79937       };
79938     } catch (std::exception& e) {
79939       {
79940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79941       };
79942     } catch (Dali::DaliException e) {
79943       {
79944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79945       };
79946     } catch (...) {
79947       {
79948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79949       };
79950     }
79951   }
79952
79953   jresult = (void *)result;
79954   return jresult;
79955 }
79956
79957
79958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79959   void * jresult ;
79960   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79961   Dali::Toolkit::ScrollView *arg2 = 0 ;
79962   Dali::Toolkit::ScrollView *result = 0 ;
79963
79964   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79965   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79966   if (!arg2) {
79967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79968     return 0;
79969   }
79970   {
79971     try {
79972       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79973     } catch (std::out_of_range& e) {
79974       {
79975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79976       };
79977     } catch (std::exception& e) {
79978       {
79979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79980       };
79981     } catch (Dali::DaliException e) {
79982       {
79983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79984       };
79985     } catch (...) {
79986       {
79987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79988       };
79989     }
79990   }
79991
79992   jresult = (void *)result;
79993   return jresult;
79994 }
79995
79996
79997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
79998   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79999
80000   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80001   {
80002     try {
80003       delete arg1;
80004     } catch (std::out_of_range& e) {
80005       {
80006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80007       };
80008     } catch (std::exception& e) {
80009       {
80010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80011       };
80012     } catch (Dali::DaliException e) {
80013       {
80014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80015       };
80016     } catch (...) {
80017       {
80018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80019       };
80020     }
80021   }
80022
80023 }
80024
80025
80026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80027   void * jresult ;
80028   Dali::Toolkit::ScrollView result;
80029
80030   {
80031     try {
80032       result = Dali::Toolkit::ScrollView::New();
80033     } catch (std::out_of_range& e) {
80034       {
80035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80036       };
80037     } catch (std::exception& e) {
80038       {
80039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80040       };
80041     } catch (Dali::DaliException e) {
80042       {
80043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80044       };
80045     } catch (...) {
80046       {
80047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80048       };
80049     }
80050   }
80051
80052   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80053   return jresult;
80054 }
80055
80056
80057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80058   void * jresult ;
80059   Dali::BaseHandle arg1 ;
80060   Dali::BaseHandle *argp1 ;
80061   Dali::Toolkit::ScrollView result;
80062
80063   argp1 = (Dali::BaseHandle *)jarg1;
80064   if (!argp1) {
80065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80066     return 0;
80067   }
80068   arg1 = *argp1;
80069   {
80070     try {
80071       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80072     } catch (std::out_of_range& e) {
80073       {
80074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80075       };
80076     } catch (std::exception& e) {
80077       {
80078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80079       };
80080     } catch (Dali::DaliException e) {
80081       {
80082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80083       };
80084     } catch (...) {
80085       {
80086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80087       };
80088     }
80089   }
80090
80091   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80092   return jresult;
80093 }
80094
80095
80096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80097   void * jresult ;
80098   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80099   Dali::AlphaFunction result;
80100
80101   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80102   {
80103     try {
80104       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80105     } catch (std::out_of_range& e) {
80106       {
80107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80108       };
80109     } catch (std::exception& e) {
80110       {
80111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80112       };
80113     } catch (Dali::DaliException e) {
80114       {
80115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80116       };
80117     } catch (...) {
80118       {
80119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80120       };
80121     }
80122   }
80123
80124   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80125   return jresult;
80126 }
80127
80128
80129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80130   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80131   Dali::AlphaFunction arg2 ;
80132   Dali::AlphaFunction *argp2 ;
80133
80134   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80135   argp2 = (Dali::AlphaFunction *)jarg2;
80136   if (!argp2) {
80137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80138     return ;
80139   }
80140   arg2 = *argp2;
80141   {
80142     try {
80143       (arg1)->SetScrollSnapAlphaFunction(arg2);
80144     } catch (std::out_of_range& e) {
80145       {
80146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80147       };
80148     } catch (std::exception& e) {
80149       {
80150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80151       };
80152     } catch (Dali::DaliException e) {
80153       {
80154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80155       };
80156     } catch (...) {
80157       {
80158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80159       };
80160     }
80161   }
80162
80163 }
80164
80165
80166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80167   void * jresult ;
80168   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80169   Dali::AlphaFunction result;
80170
80171   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80172   {
80173     try {
80174       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80175     } catch (std::out_of_range& e) {
80176       {
80177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80178       };
80179     } catch (std::exception& e) {
80180       {
80181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80182       };
80183     } catch (Dali::DaliException e) {
80184       {
80185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80186       };
80187     } catch (...) {
80188       {
80189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80190       };
80191     }
80192   }
80193
80194   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80195   return jresult;
80196 }
80197
80198
80199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80200   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80201   Dali::AlphaFunction arg2 ;
80202   Dali::AlphaFunction *argp2 ;
80203
80204   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80205   argp2 = (Dali::AlphaFunction *)jarg2;
80206   if (!argp2) {
80207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80208     return ;
80209   }
80210   arg2 = *argp2;
80211   {
80212     try {
80213       (arg1)->SetScrollFlickAlphaFunction(arg2);
80214     } catch (std::out_of_range& e) {
80215       {
80216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80217       };
80218     } catch (std::exception& e) {
80219       {
80220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80221       };
80222     } catch (Dali::DaliException e) {
80223       {
80224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80225       };
80226     } catch (...) {
80227       {
80228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80229       };
80230     }
80231   }
80232
80233 }
80234
80235
80236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80237   float jresult ;
80238   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80239   float result;
80240
80241   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80242   {
80243     try {
80244       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80245     } catch (std::out_of_range& e) {
80246       {
80247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80248       };
80249     } catch (std::exception& e) {
80250       {
80251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80252       };
80253     } catch (Dali::DaliException e) {
80254       {
80255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80256       };
80257     } catch (...) {
80258       {
80259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80260       };
80261     }
80262   }
80263
80264   jresult = result;
80265   return jresult;
80266 }
80267
80268
80269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80270   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80271   float arg2 ;
80272
80273   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80274   arg2 = (float)jarg2;
80275   {
80276     try {
80277       (arg1)->SetScrollSnapDuration(arg2);
80278     } catch (std::out_of_range& e) {
80279       {
80280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80281       };
80282     } catch (std::exception& e) {
80283       {
80284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80285       };
80286     } catch (Dali::DaliException e) {
80287       {
80288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80289       };
80290     } catch (...) {
80291       {
80292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80293       };
80294     }
80295   }
80296
80297 }
80298
80299
80300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80301   float jresult ;
80302   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80303   float result;
80304
80305   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80306   {
80307     try {
80308       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80309     } catch (std::out_of_range& e) {
80310       {
80311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80312       };
80313     } catch (std::exception& e) {
80314       {
80315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80316       };
80317     } catch (Dali::DaliException e) {
80318       {
80319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80320       };
80321     } catch (...) {
80322       {
80323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80324       };
80325     }
80326   }
80327
80328   jresult = result;
80329   return jresult;
80330 }
80331
80332
80333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80334   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80335   float arg2 ;
80336
80337   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80338   arg2 = (float)jarg2;
80339   {
80340     try {
80341       (arg1)->SetScrollFlickDuration(arg2);
80342     } catch (std::out_of_range& e) {
80343       {
80344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80345       };
80346     } catch (std::exception& e) {
80347       {
80348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80349       };
80350     } catch (Dali::DaliException e) {
80351       {
80352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80353       };
80354     } catch (...) {
80355       {
80356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80357       };
80358     }
80359   }
80360
80361 }
80362
80363
80364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80365   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80366   Dali::Toolkit::RulerPtr arg2 ;
80367   Dali::Toolkit::RulerPtr *argp2 ;
80368
80369   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80370   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80371   if (!argp2) {
80372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80373     return ;
80374   }
80375   arg2 = *argp2;
80376   {
80377     try {
80378       (arg1)->SetRulerX(arg2);
80379     } catch (std::out_of_range& e) {
80380       {
80381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80382       };
80383     } catch (std::exception& e) {
80384       {
80385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80386       };
80387     } catch (Dali::DaliException e) {
80388       {
80389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80390       };
80391     } catch (...) {
80392       {
80393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80394       };
80395     }
80396   }
80397
80398 }
80399
80400
80401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80402   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80403   Dali::Toolkit::RulerPtr arg2 ;
80404   Dali::Toolkit::RulerPtr *argp2 ;
80405
80406   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80407   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80408   if (!argp2) {
80409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80410     return ;
80411   }
80412   arg2 = *argp2;
80413   {
80414     try {
80415       (arg1)->SetRulerY(arg2);
80416     } catch (std::out_of_range& e) {
80417       {
80418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80419       };
80420     } catch (std::exception& e) {
80421       {
80422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80423       };
80424     } catch (Dali::DaliException e) {
80425       {
80426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80427       };
80428     } catch (...) {
80429       {
80430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80431       };
80432     }
80433   }
80434
80435 }
80436
80437
80438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80439   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80440   bool arg2 ;
80441
80442   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80443   arg2 = jarg2 ? true : false;
80444   {
80445     try {
80446       (arg1)->SetScrollSensitive(arg2);
80447     } catch (std::out_of_range& e) {
80448       {
80449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80450       };
80451     } catch (std::exception& e) {
80452       {
80453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80454       };
80455     } catch (Dali::DaliException e) {
80456       {
80457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80458       };
80459     } catch (...) {
80460       {
80461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80462       };
80463     }
80464   }
80465
80466 }
80467
80468
80469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80470   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80471   float arg2 ;
80472   float arg3 ;
80473
80474   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80475   arg2 = (float)jarg2;
80476   arg3 = (float)jarg3;
80477   {
80478     try {
80479       (arg1)->SetMaxOvershoot(arg2,arg3);
80480     } catch (std::out_of_range& e) {
80481       {
80482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80483       };
80484     } catch (std::exception& e) {
80485       {
80486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80487       };
80488     } catch (Dali::DaliException e) {
80489       {
80490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80491       };
80492     } catch (...) {
80493       {
80494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80495       };
80496     }
80497   }
80498
80499 }
80500
80501
80502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80503   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80504   Dali::AlphaFunction arg2 ;
80505   Dali::AlphaFunction *argp2 ;
80506
80507   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80508   argp2 = (Dali::AlphaFunction *)jarg2;
80509   if (!argp2) {
80510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80511     return ;
80512   }
80513   arg2 = *argp2;
80514   {
80515     try {
80516       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80517     } catch (std::out_of_range& e) {
80518       {
80519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80520       };
80521     } catch (std::exception& e) {
80522       {
80523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80524       };
80525     } catch (Dali::DaliException e) {
80526       {
80527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80528       };
80529     } catch (...) {
80530       {
80531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80532       };
80533     }
80534   }
80535
80536 }
80537
80538
80539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80540   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80541   float arg2 ;
80542
80543   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80544   arg2 = (float)jarg2;
80545   {
80546     try {
80547       (arg1)->SetSnapOvershootDuration(arg2);
80548     } catch (std::out_of_range& e) {
80549       {
80550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80551       };
80552     } catch (std::exception& e) {
80553       {
80554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80555       };
80556     } catch (Dali::DaliException e) {
80557       {
80558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80559       };
80560     } catch (...) {
80561       {
80562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80563       };
80564     }
80565   }
80566
80567 }
80568
80569
80570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80571   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80572   bool arg2 ;
80573
80574   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80575   arg2 = jarg2 ? true : false;
80576   {
80577     try {
80578       (arg1)->SetActorAutoSnap(arg2);
80579     } catch (std::out_of_range& e) {
80580       {
80581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80582       };
80583     } catch (std::exception& e) {
80584       {
80585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80586       };
80587     } catch (Dali::DaliException e) {
80588       {
80589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80590       };
80591     } catch (...) {
80592       {
80593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80594       };
80595     }
80596   }
80597
80598 }
80599
80600
80601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80602   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80603   bool arg2 ;
80604
80605   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80606   arg2 = jarg2 ? true : false;
80607   {
80608     try {
80609       (arg1)->SetWrapMode(arg2);
80610     } catch (std::out_of_range& e) {
80611       {
80612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80613       };
80614     } catch (std::exception& e) {
80615       {
80616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80617       };
80618     } catch (Dali::DaliException e) {
80619       {
80620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80621       };
80622     } catch (...) {
80623       {
80624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80625       };
80626     }
80627   }
80628
80629 }
80630
80631
80632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80633   int jresult ;
80634   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80635   int result;
80636
80637   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80638   {
80639     try {
80640       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80641     } catch (std::out_of_range& e) {
80642       {
80643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80644       };
80645     } catch (std::exception& e) {
80646       {
80647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80648       };
80649     } catch (Dali::DaliException e) {
80650       {
80651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80652       };
80653     } catch (...) {
80654       {
80655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80656       };
80657     }
80658   }
80659
80660   jresult = result;
80661   return jresult;
80662 }
80663
80664
80665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80666   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80667   int arg2 ;
80668
80669   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80670   arg2 = (int)jarg2;
80671   {
80672     try {
80673       (arg1)->SetScrollUpdateDistance(arg2);
80674     } catch (std::out_of_range& e) {
80675       {
80676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80677       };
80678     } catch (std::exception& e) {
80679       {
80680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80681       };
80682     } catch (Dali::DaliException e) {
80683       {
80684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80685       };
80686     } catch (...) {
80687       {
80688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80689       };
80690     }
80691   }
80692
80693 }
80694
80695
80696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80697   unsigned int jresult ;
80698   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80699   bool result;
80700
80701   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80702   {
80703     try {
80704       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80705     } catch (std::out_of_range& e) {
80706       {
80707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80708       };
80709     } catch (std::exception& e) {
80710       {
80711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80712       };
80713     } catch (Dali::DaliException e) {
80714       {
80715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80716       };
80717     } catch (...) {
80718       {
80719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80720       };
80721     }
80722   }
80723
80724   jresult = result;
80725   return jresult;
80726 }
80727
80728
80729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80730   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80731   bool arg2 ;
80732
80733   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80734   arg2 = jarg2 ? true : false;
80735   {
80736     try {
80737       (arg1)->SetAxisAutoLock(arg2);
80738     } catch (std::out_of_range& e) {
80739       {
80740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80741       };
80742     } catch (std::exception& e) {
80743       {
80744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80745       };
80746     } catch (Dali::DaliException e) {
80747       {
80748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80749       };
80750     } catch (...) {
80751       {
80752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80753       };
80754     }
80755   }
80756
80757 }
80758
80759
80760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80761   float jresult ;
80762   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80763   float result;
80764
80765   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80766   {
80767     try {
80768       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80769     } catch (std::out_of_range& e) {
80770       {
80771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80772       };
80773     } catch (std::exception& e) {
80774       {
80775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80776       };
80777     } catch (Dali::DaliException e) {
80778       {
80779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80780       };
80781     } catch (...) {
80782       {
80783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80784       };
80785     }
80786   }
80787
80788   jresult = result;
80789   return jresult;
80790 }
80791
80792
80793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80794   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80795   float arg2 ;
80796
80797   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80798   arg2 = (float)jarg2;
80799   {
80800     try {
80801       (arg1)->SetAxisAutoLockGradient(arg2);
80802     } catch (std::out_of_range& e) {
80803       {
80804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80805       };
80806     } catch (std::exception& e) {
80807       {
80808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80809       };
80810     } catch (Dali::DaliException e) {
80811       {
80812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80813       };
80814     } catch (...) {
80815       {
80816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80817       };
80818     }
80819   }
80820
80821 }
80822
80823
80824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80825   float jresult ;
80826   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80827   float result;
80828
80829   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80830   {
80831     try {
80832       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80833     } catch (std::out_of_range& e) {
80834       {
80835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80836       };
80837     } catch (std::exception& e) {
80838       {
80839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80840       };
80841     } catch (Dali::DaliException e) {
80842       {
80843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80844       };
80845     } catch (...) {
80846       {
80847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80848       };
80849     }
80850   }
80851
80852   jresult = result;
80853   return jresult;
80854 }
80855
80856
80857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80858   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80859   float arg2 ;
80860
80861   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80862   arg2 = (float)jarg2;
80863   {
80864     try {
80865       (arg1)->SetFrictionCoefficient(arg2);
80866     } catch (std::out_of_range& e) {
80867       {
80868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80869       };
80870     } catch (std::exception& e) {
80871       {
80872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80873       };
80874     } catch (Dali::DaliException e) {
80875       {
80876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80877       };
80878     } catch (...) {
80879       {
80880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80881       };
80882     }
80883   }
80884
80885 }
80886
80887
80888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80889   float jresult ;
80890   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80891   float result;
80892
80893   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80894   {
80895     try {
80896       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80897     } catch (std::out_of_range& e) {
80898       {
80899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80900       };
80901     } catch (std::exception& e) {
80902       {
80903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80904       };
80905     } catch (Dali::DaliException e) {
80906       {
80907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80908       };
80909     } catch (...) {
80910       {
80911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80912       };
80913     }
80914   }
80915
80916   jresult = result;
80917   return jresult;
80918 }
80919
80920
80921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80922   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80923   float arg2 ;
80924
80925   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80926   arg2 = (float)jarg2;
80927   {
80928     try {
80929       (arg1)->SetFlickSpeedCoefficient(arg2);
80930     } catch (std::out_of_range& e) {
80931       {
80932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80933       };
80934     } catch (std::exception& e) {
80935       {
80936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80937       };
80938     } catch (Dali::DaliException e) {
80939       {
80940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80941       };
80942     } catch (...) {
80943       {
80944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80945       };
80946     }
80947   }
80948
80949 }
80950
80951
80952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80953   void * jresult ;
80954   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80955   Dali::Vector2 result;
80956
80957   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80958   {
80959     try {
80960       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80961     } catch (std::out_of_range& e) {
80962       {
80963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80964       };
80965     } catch (std::exception& e) {
80966       {
80967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80968       };
80969     } catch (Dali::DaliException e) {
80970       {
80971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80972       };
80973     } catch (...) {
80974       {
80975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80976       };
80977     }
80978   }
80979
80980   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80981   return jresult;
80982 }
80983
80984
80985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80986   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80987   Dali::Vector2 *arg2 = 0 ;
80988
80989   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80990   arg2 = (Dali::Vector2 *)jarg2;
80991   if (!arg2) {
80992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80993     return ;
80994   }
80995   {
80996     try {
80997       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
80998     } catch (std::out_of_range& e) {
80999       {
81000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81001       };
81002     } catch (std::exception& e) {
81003       {
81004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81005       };
81006     } catch (Dali::DaliException e) {
81007       {
81008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81009       };
81010     } catch (...) {
81011       {
81012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81013       };
81014     }
81015   }
81016
81017 }
81018
81019
81020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81021   float jresult ;
81022   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81023   float result;
81024
81025   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81026   {
81027     try {
81028       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81029     } catch (std::out_of_range& e) {
81030       {
81031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81032       };
81033     } catch (std::exception& e) {
81034       {
81035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81036       };
81037     } catch (Dali::DaliException e) {
81038       {
81039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81040       };
81041     } catch (...) {
81042       {
81043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81044       };
81045     }
81046   }
81047
81048   jresult = result;
81049   return jresult;
81050 }
81051
81052
81053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81054   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81055   float arg2 ;
81056
81057   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81058   arg2 = (float)jarg2;
81059   {
81060     try {
81061       (arg1)->SetMinimumSpeedForFlick(arg2);
81062     } catch (std::out_of_range& e) {
81063       {
81064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81065       };
81066     } catch (std::exception& e) {
81067       {
81068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81069       };
81070     } catch (Dali::DaliException e) {
81071       {
81072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81073       };
81074     } catch (...) {
81075       {
81076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81077       };
81078     }
81079   }
81080
81081 }
81082
81083
81084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81085   float jresult ;
81086   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81087   float result;
81088
81089   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81090   {
81091     try {
81092       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81093     } catch (std::out_of_range& e) {
81094       {
81095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81096       };
81097     } catch (std::exception& e) {
81098       {
81099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81100       };
81101     } catch (Dali::DaliException e) {
81102       {
81103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81104       };
81105     } catch (...) {
81106       {
81107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81108       };
81109     }
81110   }
81111
81112   jresult = result;
81113   return jresult;
81114 }
81115
81116
81117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81118   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81119   float arg2 ;
81120
81121   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81122   arg2 = (float)jarg2;
81123   {
81124     try {
81125       (arg1)->SetMaxFlickSpeed(arg2);
81126     } catch (std::out_of_range& e) {
81127       {
81128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81129       };
81130     } catch (std::exception& e) {
81131       {
81132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81133       };
81134     } catch (Dali::DaliException e) {
81135       {
81136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81137       };
81138     } catch (...) {
81139       {
81140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81141       };
81142     }
81143   }
81144
81145 }
81146
81147
81148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81149   void * jresult ;
81150   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81151   Dali::Vector2 result;
81152
81153   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81154   {
81155     try {
81156       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81157     } catch (std::out_of_range& e) {
81158       {
81159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81160       };
81161     } catch (std::exception& e) {
81162       {
81163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81164       };
81165     } catch (Dali::DaliException e) {
81166       {
81167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81168       };
81169     } catch (...) {
81170       {
81171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81172       };
81173     }
81174   }
81175
81176   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81177   return jresult;
81178 }
81179
81180
81181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81182   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81183   Dali::Vector2 arg2 ;
81184   Dali::Vector2 *argp2 ;
81185
81186   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81187   argp2 = (Dali::Vector2 *)jarg2;
81188   if (!argp2) {
81189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81190     return ;
81191   }
81192   arg2 = *argp2;
81193   {
81194     try {
81195       (arg1)->SetWheelScrollDistanceStep(arg2);
81196     } catch (std::out_of_range& e) {
81197       {
81198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81199       };
81200     } catch (std::exception& e) {
81201       {
81202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81203       };
81204     } catch (Dali::DaliException e) {
81205       {
81206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81207       };
81208     } catch (...) {
81209       {
81210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81211       };
81212     }
81213   }
81214
81215 }
81216
81217
81218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81219   void * jresult ;
81220   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81221   Dali::Vector2 result;
81222
81223   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81224   {
81225     try {
81226       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81227     } catch (std::out_of_range& e) {
81228       {
81229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81230       };
81231     } catch (std::exception& e) {
81232       {
81233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81234       };
81235     } catch (Dali::DaliException e) {
81236       {
81237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81238       };
81239     } catch (...) {
81240       {
81241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81242       };
81243     }
81244   }
81245
81246   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81247   return jresult;
81248 }
81249
81250
81251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81252   unsigned int jresult ;
81253   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81254   unsigned int result;
81255
81256   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81257   {
81258     try {
81259       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81260     } catch (std::out_of_range& e) {
81261       {
81262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81263       };
81264     } catch (std::exception& e) {
81265       {
81266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81267       };
81268     } catch (Dali::DaliException e) {
81269       {
81270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81271       };
81272     } catch (...) {
81273       {
81274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81275       };
81276     }
81277   }
81278
81279   jresult = result;
81280   return jresult;
81281 }
81282
81283
81284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81285   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81286   Dali::Vector2 *arg2 = 0 ;
81287
81288   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81289   arg2 = (Dali::Vector2 *)jarg2;
81290   if (!arg2) {
81291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81292     return ;
81293   }
81294   {
81295     try {
81296       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81297     } catch (std::out_of_range& e) {
81298       {
81299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81300       };
81301     } catch (std::exception& e) {
81302       {
81303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81304       };
81305     } catch (Dali::DaliException e) {
81306       {
81307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81308       };
81309     } catch (...) {
81310       {
81311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81312       };
81313     }
81314   }
81315
81316 }
81317
81318
81319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81320   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81321   Dali::Vector2 *arg2 = 0 ;
81322   float arg3 ;
81323
81324   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81325   arg2 = (Dali::Vector2 *)jarg2;
81326   if (!arg2) {
81327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81328     return ;
81329   }
81330   arg3 = (float)jarg3;
81331   {
81332     try {
81333       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81334     } catch (std::out_of_range& e) {
81335       {
81336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81337       };
81338     } catch (std::exception& e) {
81339       {
81340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81341       };
81342     } catch (Dali::DaliException e) {
81343       {
81344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81345       };
81346     } catch (...) {
81347       {
81348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81349       };
81350     }
81351   }
81352
81353 }
81354
81355
81356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81357   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81358   Dali::Vector2 *arg2 = 0 ;
81359   float arg3 ;
81360   Dali::AlphaFunction arg4 ;
81361   Dali::AlphaFunction *argp4 ;
81362
81363   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81364   arg2 = (Dali::Vector2 *)jarg2;
81365   if (!arg2) {
81366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81367     return ;
81368   }
81369   arg3 = (float)jarg3;
81370   argp4 = (Dali::AlphaFunction *)jarg4;
81371   if (!argp4) {
81372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81373     return ;
81374   }
81375   arg4 = *argp4;
81376   {
81377     try {
81378       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81379     } catch (std::out_of_range& e) {
81380       {
81381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81382       };
81383     } catch (std::exception& e) {
81384       {
81385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81386       };
81387     } catch (Dali::DaliException e) {
81388       {
81389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81390       };
81391     } catch (...) {
81392       {
81393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81394       };
81395     }
81396   }
81397
81398 }
81399
81400
81401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81402   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81403   Dali::Vector2 *arg2 = 0 ;
81404   float arg3 ;
81405   Dali::Toolkit::DirectionBias arg4 ;
81406   Dali::Toolkit::DirectionBias arg5 ;
81407
81408   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81409   arg2 = (Dali::Vector2 *)jarg2;
81410   if (!arg2) {
81411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81412     return ;
81413   }
81414   arg3 = (float)jarg3;
81415   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81416   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81417   {
81418     try {
81419       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81420     } catch (std::out_of_range& e) {
81421       {
81422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81423       };
81424     } catch (std::exception& e) {
81425       {
81426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81427       };
81428     } catch (Dali::DaliException e) {
81429       {
81430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81431       };
81432     } catch (...) {
81433       {
81434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81435       };
81436     }
81437   }
81438
81439 }
81440
81441
81442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81443   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81444   Dali::Vector2 *arg2 = 0 ;
81445   float arg3 ;
81446   Dali::AlphaFunction arg4 ;
81447   Dali::Toolkit::DirectionBias arg5 ;
81448   Dali::Toolkit::DirectionBias arg6 ;
81449   Dali::AlphaFunction *argp4 ;
81450
81451   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81452   arg2 = (Dali::Vector2 *)jarg2;
81453   if (!arg2) {
81454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81455     return ;
81456   }
81457   arg3 = (float)jarg3;
81458   argp4 = (Dali::AlphaFunction *)jarg4;
81459   if (!argp4) {
81460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81461     return ;
81462   }
81463   arg4 = *argp4;
81464   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81465   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81466   {
81467     try {
81468       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81469     } catch (std::out_of_range& e) {
81470       {
81471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81472       };
81473     } catch (std::exception& e) {
81474       {
81475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81476       };
81477     } catch (Dali::DaliException e) {
81478       {
81479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81480       };
81481     } catch (...) {
81482       {
81483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81484       };
81485     }
81486   }
81487
81488 }
81489
81490
81491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81492   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81493   unsigned int arg2 ;
81494
81495   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81496   arg2 = (unsigned int)jarg2;
81497   {
81498     try {
81499       (arg1)->ScrollTo(arg2);
81500     } catch (std::out_of_range& e) {
81501       {
81502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81503       };
81504     } catch (std::exception& e) {
81505       {
81506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81507       };
81508     } catch (Dali::DaliException e) {
81509       {
81510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81511       };
81512     } catch (...) {
81513       {
81514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81515       };
81516     }
81517   }
81518
81519 }
81520
81521
81522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81523   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81524   unsigned int arg2 ;
81525   float arg3 ;
81526
81527   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81528   arg2 = (unsigned int)jarg2;
81529   arg3 = (float)jarg3;
81530   {
81531     try {
81532       (arg1)->ScrollTo(arg2,arg3);
81533     } catch (std::out_of_range& e) {
81534       {
81535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81536       };
81537     } catch (std::exception& e) {
81538       {
81539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81540       };
81541     } catch (Dali::DaliException e) {
81542       {
81543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81544       };
81545     } catch (...) {
81546       {
81547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81548       };
81549     }
81550   }
81551
81552 }
81553
81554
81555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81556   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81557   unsigned int arg2 ;
81558   float arg3 ;
81559   Dali::Toolkit::DirectionBias arg4 ;
81560
81561   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81562   arg2 = (unsigned int)jarg2;
81563   arg3 = (float)jarg3;
81564   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81565   {
81566     try {
81567       (arg1)->ScrollTo(arg2,arg3,arg4);
81568     } catch (std::out_of_range& e) {
81569       {
81570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81571       };
81572     } catch (std::exception& e) {
81573       {
81574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81575       };
81576     } catch (Dali::DaliException e) {
81577       {
81578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81579       };
81580     } catch (...) {
81581       {
81582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81583       };
81584     }
81585   }
81586
81587 }
81588
81589
81590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81591   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81592   Dali::Actor *arg2 = 0 ;
81593
81594   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81595   arg2 = (Dali::Actor *)jarg2;
81596   if (!arg2) {
81597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81598     return ;
81599   }
81600   {
81601     try {
81602       (arg1)->ScrollTo(*arg2);
81603     } catch (std::out_of_range& e) {
81604       {
81605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81606       };
81607     } catch (std::exception& e) {
81608       {
81609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81610       };
81611     } catch (Dali::DaliException e) {
81612       {
81613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81614       };
81615     } catch (...) {
81616       {
81617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81618       };
81619     }
81620   }
81621
81622 }
81623
81624
81625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81626   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81627   Dali::Actor *arg2 = 0 ;
81628   float arg3 ;
81629
81630   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81631   arg2 = (Dali::Actor *)jarg2;
81632   if (!arg2) {
81633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81634     return ;
81635   }
81636   arg3 = (float)jarg3;
81637   {
81638     try {
81639       (arg1)->ScrollTo(*arg2,arg3);
81640     } catch (std::out_of_range& e) {
81641       {
81642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81643       };
81644     } catch (std::exception& e) {
81645       {
81646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81647       };
81648     } catch (Dali::DaliException e) {
81649       {
81650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81651       };
81652     } catch (...) {
81653       {
81654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81655       };
81656     }
81657   }
81658
81659 }
81660
81661
81662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81663   unsigned int jresult ;
81664   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81665   bool result;
81666
81667   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81668   {
81669     try {
81670       result = (bool)(arg1)->ScrollToSnapPoint();
81671     } catch (std::out_of_range& e) {
81672       {
81673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81674       };
81675     } catch (std::exception& e) {
81676       {
81677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81678       };
81679     } catch (Dali::DaliException e) {
81680       {
81681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81682       };
81683     } catch (...) {
81684       {
81685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81686       };
81687     }
81688   }
81689
81690   jresult = result;
81691   return jresult;
81692 }
81693
81694
81695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81696   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81697   Dali::Constraint arg2 ;
81698   Dali::Constraint *argp2 ;
81699
81700   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81701   argp2 = (Dali::Constraint *)jarg2;
81702   if (!argp2) {
81703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81704     return ;
81705   }
81706   arg2 = *argp2;
81707   {
81708     try {
81709       (arg1)->ApplyConstraintToChildren(arg2);
81710     } catch (std::out_of_range& e) {
81711       {
81712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81713       };
81714     } catch (std::exception& e) {
81715       {
81716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81717       };
81718     } catch (Dali::DaliException e) {
81719       {
81720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81721       };
81722     } catch (...) {
81723       {
81724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81725       };
81726     }
81727   }
81728
81729 }
81730
81731
81732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81734
81735   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81736   {
81737     try {
81738       (arg1)->RemoveConstraintsFromChildren();
81739     } catch (std::out_of_range& e) {
81740       {
81741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81742       };
81743     } catch (std::exception& e) {
81744       {
81745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81746       };
81747     } catch (Dali::DaliException e) {
81748       {
81749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81750       };
81751     } catch (...) {
81752       {
81753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81754       };
81755     }
81756   }
81757
81758 }
81759
81760
81761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81762   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81763   Dali::Toolkit::ScrollViewEffect arg2 ;
81764   Dali::Toolkit::ScrollViewEffect *argp2 ;
81765
81766   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81767   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81768   if (!argp2) {
81769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81770     return ;
81771   }
81772   arg2 = *argp2;
81773   {
81774     try {
81775       (arg1)->ApplyEffect(arg2);
81776     } catch (std::out_of_range& e) {
81777       {
81778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81779       };
81780     } catch (std::exception& e) {
81781       {
81782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81783       };
81784     } catch (Dali::DaliException e) {
81785       {
81786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81787       };
81788     } catch (...) {
81789       {
81790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81791       };
81792     }
81793   }
81794
81795 }
81796
81797
81798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81799   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81800   Dali::Toolkit::ScrollViewEffect arg2 ;
81801   Dali::Toolkit::ScrollViewEffect *argp2 ;
81802
81803   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81804   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81805   if (!argp2) {
81806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81807     return ;
81808   }
81809   arg2 = *argp2;
81810   {
81811     try {
81812       (arg1)->RemoveEffect(arg2);
81813     } catch (std::out_of_range& e) {
81814       {
81815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81816       };
81817     } catch (std::exception& e) {
81818       {
81819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81820       };
81821     } catch (Dali::DaliException e) {
81822       {
81823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81824       };
81825     } catch (...) {
81826       {
81827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81828       };
81829     }
81830   }
81831
81832 }
81833
81834
81835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81836   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81837
81838   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81839   {
81840     try {
81841       (arg1)->RemoveAllEffects();
81842     } catch (std::out_of_range& e) {
81843       {
81844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81845       };
81846     } catch (std::exception& e) {
81847       {
81848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81849       };
81850     } catch (Dali::DaliException e) {
81851       {
81852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81853       };
81854     } catch (...) {
81855       {
81856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81857       };
81858     }
81859   }
81860
81861 }
81862
81863
81864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81865   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81866   Dali::Actor arg2 ;
81867   Dali::Actor *argp2 ;
81868
81869   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81870   argp2 = (Dali::Actor *)jarg2;
81871   if (!argp2) {
81872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81873     return ;
81874   }
81875   arg2 = *argp2;
81876   {
81877     try {
81878       (arg1)->BindActor(arg2);
81879     } catch (std::out_of_range& e) {
81880       {
81881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81882       };
81883     } catch (std::exception& e) {
81884       {
81885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81886       };
81887     } catch (Dali::DaliException e) {
81888       {
81889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81890       };
81891     } catch (...) {
81892       {
81893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81894       };
81895     }
81896   }
81897
81898 }
81899
81900
81901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81902   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81903   Dali::Actor arg2 ;
81904   Dali::Actor *argp2 ;
81905
81906   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81907   argp2 = (Dali::Actor *)jarg2;
81908   if (!argp2) {
81909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81910     return ;
81911   }
81912   arg2 = *argp2;
81913   {
81914     try {
81915       (arg1)->UnbindActor(arg2);
81916     } catch (std::out_of_range& e) {
81917       {
81918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81919       };
81920     } catch (std::exception& e) {
81921       {
81922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81923       };
81924     } catch (Dali::DaliException e) {
81925       {
81926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81927       };
81928     } catch (...) {
81929       {
81930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81931       };
81932     }
81933   }
81934
81935 }
81936
81937
81938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81939   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81940   Dali::Radian arg2 ;
81941   Dali::Radian arg3 ;
81942   Dali::Radian *argp2 ;
81943   Dali::Radian *argp3 ;
81944
81945   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81946   argp2 = (Dali::Radian *)jarg2;
81947   if (!argp2) {
81948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81949     return ;
81950   }
81951   arg2 = *argp2;
81952   argp3 = (Dali::Radian *)jarg3;
81953   if (!argp3) {
81954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81955     return ;
81956   }
81957   arg3 = *argp3;
81958   {
81959     try {
81960       (arg1)->SetScrollingDirection(arg2,arg3);
81961     } catch (std::out_of_range& e) {
81962       {
81963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81964       };
81965     } catch (std::exception& e) {
81966       {
81967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81968       };
81969     } catch (Dali::DaliException e) {
81970       {
81971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81972       };
81973     } catch (...) {
81974       {
81975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81976       };
81977     }
81978   }
81979
81980 }
81981
81982
81983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81984   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81985   Dali::Radian arg2 ;
81986   Dali::Radian *argp2 ;
81987
81988   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81989   argp2 = (Dali::Radian *)jarg2;
81990   if (!argp2) {
81991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81992     return ;
81993   }
81994   arg2 = *argp2;
81995   {
81996     try {
81997       (arg1)->SetScrollingDirection(arg2);
81998     } catch (std::out_of_range& e) {
81999       {
82000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82001       };
82002     } catch (std::exception& e) {
82003       {
82004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82005       };
82006     } catch (Dali::DaliException e) {
82007       {
82008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82009       };
82010     } catch (...) {
82011       {
82012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82013       };
82014     }
82015   }
82016
82017 }
82018
82019
82020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82021   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82022   Dali::Radian arg2 ;
82023   Dali::Radian *argp2 ;
82024
82025   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82026   argp2 = (Dali::Radian *)jarg2;
82027   if (!argp2) {
82028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82029     return ;
82030   }
82031   arg2 = *argp2;
82032   {
82033     try {
82034       (arg1)->RemoveScrollingDirection(arg2);
82035     } catch (std::out_of_range& e) {
82036       {
82037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82038       };
82039     } catch (std::exception& e) {
82040       {
82041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82042       };
82043     } catch (Dali::DaliException e) {
82044       {
82045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82046       };
82047     } catch (...) {
82048       {
82049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82050       };
82051     }
82052   }
82053
82054 }
82055
82056
82057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82058   void * jresult ;
82059   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82060   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82061
82062   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82063   {
82064     try {
82065       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82066     } catch (std::out_of_range& e) {
82067       {
82068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82069       };
82070     } catch (std::exception& e) {
82071       {
82072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82073       };
82074     } catch (Dali::DaliException e) {
82075       {
82076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82077       };
82078     } catch (...) {
82079       {
82080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82081       };
82082     }
82083   }
82084
82085   jresult = (void *)result;
82086   return jresult;
82087 }
82088
82089
82090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82091   int jresult ;
82092   int result;
82093
82094   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82095   jresult = (int)result;
82096   return jresult;
82097 }
82098
82099
82100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82101   int jresult ;
82102   int result;
82103
82104   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82105   jresult = (int)result;
82106   return jresult;
82107 }
82108
82109
82110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82111   int jresult ;
82112   int result;
82113
82114   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82115   jresult = (int)result;
82116   return jresult;
82117 }
82118
82119
82120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82121   int jresult ;
82122   int result;
82123
82124   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82125   jresult = (int)result;
82126   return jresult;
82127 }
82128
82129
82130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82131   int jresult ;
82132   int result;
82133
82134   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82135   jresult = (int)result;
82136   return jresult;
82137 }
82138
82139
82140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82141   void * jresult ;
82142   Dali::Toolkit::TableView::Property *result = 0 ;
82143
82144   {
82145     try {
82146       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82147     } catch (std::out_of_range& e) {
82148       {
82149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82150       };
82151     } catch (std::exception& e) {
82152       {
82153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82154       };
82155     } catch (Dali::DaliException e) {
82156       {
82157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82158       };
82159     } catch (...) {
82160       {
82161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82162       };
82163     }
82164   }
82165
82166   jresult = (void *)result;
82167   return jresult;
82168 }
82169
82170
82171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82172   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82173
82174   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82175   {
82176     try {
82177       delete arg1;
82178     } catch (std::out_of_range& e) {
82179       {
82180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82181       };
82182     } catch (std::exception& e) {
82183       {
82184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82185       };
82186     } catch (Dali::DaliException e) {
82187       {
82188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82189       };
82190     } catch (...) {
82191       {
82192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82193       };
82194     }
82195   }
82196
82197 }
82198
82199
82200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82201   int jresult ;
82202   int result;
82203
82204   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82205   jresult = (int)result;
82206   return jresult;
82207 }
82208
82209
82210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82211   int jresult ;
82212   int result;
82213
82214   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82215   jresult = (int)result;
82216   return jresult;
82217 }
82218
82219
82220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82221   int jresult ;
82222   int result;
82223
82224   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82225   jresult = (int)result;
82226   return jresult;
82227 }
82228
82229
82230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82231   int jresult ;
82232   int result;
82233
82234   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82235   jresult = (int)result;
82236   return jresult;
82237 }
82238
82239
82240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82241   int jresult ;
82242   int result;
82243
82244   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82245   jresult = (int)result;
82246   return jresult;
82247 }
82248
82249
82250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82251   void * jresult ;
82252   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82253
82254   {
82255     try {
82256       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82257     } catch (std::out_of_range& e) {
82258       {
82259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82260       };
82261     } catch (std::exception& e) {
82262       {
82263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82264       };
82265     } catch (Dali::DaliException e) {
82266       {
82267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82268       };
82269     } catch (...) {
82270       {
82271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82272       };
82273     }
82274   }
82275
82276   jresult = (void *)result;
82277   return jresult;
82278 }
82279
82280
82281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82282   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82283
82284   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82285   {
82286     try {
82287       delete arg1;
82288     } catch (std::out_of_range& e) {
82289       {
82290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82291       };
82292     } catch (std::exception& e) {
82293       {
82294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82295       };
82296     } catch (Dali::DaliException e) {
82297       {
82298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82299       };
82300     } catch (...) {
82301       {
82302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82303       };
82304     }
82305   }
82306
82307 }
82308
82309
82310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82311   void * jresult ;
82312   unsigned int arg1 ;
82313   unsigned int arg2 ;
82314   unsigned int arg3 ;
82315   unsigned int arg4 ;
82316   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82317
82318   arg1 = (unsigned int)jarg1;
82319   arg2 = (unsigned int)jarg2;
82320   arg3 = (unsigned int)jarg3;
82321   arg4 = (unsigned int)jarg4;
82322   {
82323     try {
82324       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82325     } catch (std::out_of_range& e) {
82326       {
82327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82328       };
82329     } catch (std::exception& e) {
82330       {
82331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82332       };
82333     } catch (Dali::DaliException e) {
82334       {
82335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82336       };
82337     } catch (...) {
82338       {
82339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82340       };
82341     }
82342   }
82343
82344   jresult = (void *)result;
82345   return jresult;
82346 }
82347
82348
82349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82350   void * jresult ;
82351   unsigned int arg1 ;
82352   unsigned int arg2 ;
82353   unsigned int arg3 ;
82354   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82355
82356   arg1 = (unsigned int)jarg1;
82357   arg2 = (unsigned int)jarg2;
82358   arg3 = (unsigned int)jarg3;
82359   {
82360     try {
82361       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82362     } catch (std::out_of_range& e) {
82363       {
82364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82365       };
82366     } catch (std::exception& e) {
82367       {
82368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82369       };
82370     } catch (Dali::DaliException e) {
82371       {
82372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82373       };
82374     } catch (...) {
82375       {
82376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82377       };
82378     }
82379   }
82380
82381   jresult = (void *)result;
82382   return jresult;
82383 }
82384
82385
82386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82387   void * jresult ;
82388   unsigned int arg1 ;
82389   unsigned int arg2 ;
82390   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82391
82392   arg1 = (unsigned int)jarg1;
82393   arg2 = (unsigned int)jarg2;
82394   {
82395     try {
82396       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82397     } catch (std::out_of_range& e) {
82398       {
82399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82400       };
82401     } catch (std::exception& e) {
82402       {
82403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82404       };
82405     } catch (Dali::DaliException e) {
82406       {
82407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82408       };
82409     } catch (...) {
82410       {
82411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82412       };
82413     }
82414   }
82415
82416   jresult = (void *)result;
82417   return jresult;
82418 }
82419
82420
82421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82422   void * jresult ;
82423   unsigned int arg1 ;
82424   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82425
82426   arg1 = (unsigned int)jarg1;
82427   {
82428     try {
82429       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82430     } catch (std::out_of_range& e) {
82431       {
82432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82433       };
82434     } catch (std::exception& e) {
82435       {
82436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82437       };
82438     } catch (Dali::DaliException e) {
82439       {
82440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82441       };
82442     } catch (...) {
82443       {
82444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82445       };
82446     }
82447   }
82448
82449   jresult = (void *)result;
82450   return jresult;
82451 }
82452
82453
82454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82455   void * jresult ;
82456   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82457
82458   {
82459     try {
82460       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82461     } catch (std::out_of_range& e) {
82462       {
82463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82464       };
82465     } catch (std::exception& e) {
82466       {
82467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82468       };
82469     } catch (Dali::DaliException e) {
82470       {
82471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82472       };
82473     } catch (...) {
82474       {
82475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82476       };
82477     }
82478   }
82479
82480   jresult = (void *)result;
82481   return jresult;
82482 }
82483
82484
82485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82486   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82487   unsigned int arg2 ;
82488
82489   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82490   arg2 = (unsigned int)jarg2;
82491   if (arg1) (arg1)->rowIndex = arg2;
82492 }
82493
82494
82495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82496   unsigned int jresult ;
82497   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82498   unsigned int result;
82499
82500   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82501   result = (unsigned int) ((arg1)->rowIndex);
82502   jresult = result;
82503   return jresult;
82504 }
82505
82506
82507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82508   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82509   unsigned int arg2 ;
82510
82511   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82512   arg2 = (unsigned int)jarg2;
82513   if (arg1) (arg1)->columnIndex = arg2;
82514 }
82515
82516
82517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82518   unsigned int jresult ;
82519   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82520   unsigned int result;
82521
82522   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82523   result = (unsigned int) ((arg1)->columnIndex);
82524   jresult = result;
82525   return jresult;
82526 }
82527
82528
82529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82530   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82531   unsigned int arg2 ;
82532
82533   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82534   arg2 = (unsigned int)jarg2;
82535   if (arg1) (arg1)->rowSpan = arg2;
82536 }
82537
82538
82539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82540   unsigned int jresult ;
82541   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82542   unsigned int result;
82543
82544   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82545   result = (unsigned int) ((arg1)->rowSpan);
82546   jresult = result;
82547   return jresult;
82548 }
82549
82550
82551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82552   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82553   unsigned int arg2 ;
82554
82555   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82556   arg2 = (unsigned int)jarg2;
82557   if (arg1) (arg1)->columnSpan = arg2;
82558 }
82559
82560
82561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82562   unsigned int jresult ;
82563   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82564   unsigned int result;
82565
82566   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82567   result = (unsigned int) ((arg1)->columnSpan);
82568   jresult = result;
82569   return jresult;
82570 }
82571
82572
82573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82574   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82575
82576   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82577   {
82578     try {
82579       delete arg1;
82580     } catch (std::out_of_range& e) {
82581       {
82582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82583       };
82584     } catch (std::exception& e) {
82585       {
82586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82587       };
82588     } catch (Dali::DaliException e) {
82589       {
82590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82591       };
82592     } catch (...) {
82593       {
82594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82595       };
82596     }
82597   }
82598
82599 }
82600
82601
82602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82603   void * jresult ;
82604   Dali::Toolkit::TableView *result = 0 ;
82605
82606   {
82607     try {
82608       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82609     } catch (std::out_of_range& e) {
82610       {
82611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82612       };
82613     } catch (std::exception& e) {
82614       {
82615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82616       };
82617     } catch (Dali::DaliException e) {
82618       {
82619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82620       };
82621     } catch (...) {
82622       {
82623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82624       };
82625     }
82626   }
82627
82628   jresult = (void *)result;
82629   return jresult;
82630 }
82631
82632
82633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82634   void * jresult ;
82635   Dali::Toolkit::TableView *arg1 = 0 ;
82636   Dali::Toolkit::TableView *result = 0 ;
82637
82638   arg1 = (Dali::Toolkit::TableView *)jarg1;
82639   if (!arg1) {
82640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82641     return 0;
82642   }
82643   {
82644     try {
82645       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82646     } catch (std::out_of_range& e) {
82647       {
82648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82649       };
82650     } catch (std::exception& e) {
82651       {
82652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82653       };
82654     } catch (Dali::DaliException e) {
82655       {
82656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82657       };
82658     } catch (...) {
82659       {
82660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82661       };
82662     }
82663   }
82664
82665   jresult = (void *)result;
82666   return jresult;
82667 }
82668
82669
82670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82671   void * jresult ;
82672   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82673   Dali::Toolkit::TableView *arg2 = 0 ;
82674   Dali::Toolkit::TableView *result = 0 ;
82675
82676   arg1 = (Dali::Toolkit::TableView *)jarg1;
82677   arg2 = (Dali::Toolkit::TableView *)jarg2;
82678   if (!arg2) {
82679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82680     return 0;
82681   }
82682   {
82683     try {
82684       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82685     } catch (std::out_of_range& e) {
82686       {
82687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82688       };
82689     } catch (std::exception& e) {
82690       {
82691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82692       };
82693     } catch (Dali::DaliException e) {
82694       {
82695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82696       };
82697     } catch (...) {
82698       {
82699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82700       };
82701     }
82702   }
82703
82704   jresult = (void *)result;
82705   return jresult;
82706 }
82707
82708
82709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82710   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82711
82712   arg1 = (Dali::Toolkit::TableView *)jarg1;
82713   {
82714     try {
82715       delete arg1;
82716     } catch (std::out_of_range& e) {
82717       {
82718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82719       };
82720     } catch (std::exception& e) {
82721       {
82722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82723       };
82724     } catch (Dali::DaliException e) {
82725       {
82726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82727       };
82728     } catch (...) {
82729       {
82730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82731       };
82732     }
82733   }
82734
82735 }
82736
82737
82738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82739   void * jresult ;
82740   unsigned int arg1 ;
82741   unsigned int arg2 ;
82742   Dali::Toolkit::TableView result;
82743
82744   arg1 = (unsigned int)jarg1;
82745   arg2 = (unsigned int)jarg2;
82746   {
82747     try {
82748       result = Dali::Toolkit::TableView::New(arg1,arg2);
82749     } catch (std::out_of_range& e) {
82750       {
82751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82752       };
82753     } catch (std::exception& e) {
82754       {
82755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82756       };
82757     } catch (Dali::DaliException e) {
82758       {
82759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82760       };
82761     } catch (...) {
82762       {
82763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82764       };
82765     }
82766   }
82767
82768   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82769   return jresult;
82770 }
82771
82772
82773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82774   void * jresult ;
82775   Dali::BaseHandle arg1 ;
82776   Dali::BaseHandle *argp1 ;
82777   Dali::Toolkit::TableView result;
82778
82779   argp1 = (Dali::BaseHandle *)jarg1;
82780   if (!argp1) {
82781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82782     return 0;
82783   }
82784   arg1 = *argp1;
82785   {
82786     try {
82787       result = Dali::Toolkit::TableView::DownCast(arg1);
82788     } catch (std::out_of_range& e) {
82789       {
82790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82791       };
82792     } catch (std::exception& e) {
82793       {
82794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82795       };
82796     } catch (Dali::DaliException e) {
82797       {
82798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82799       };
82800     } catch (...) {
82801       {
82802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82803       };
82804     }
82805   }
82806
82807   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82808   return jresult;
82809 }
82810
82811
82812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82813   unsigned int jresult ;
82814   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82815   Dali::Actor arg2 ;
82816   Dali::Toolkit::TableView::CellPosition arg3 ;
82817   Dali::Actor *argp2 ;
82818   Dali::Toolkit::TableView::CellPosition *argp3 ;
82819   bool result;
82820
82821   arg1 = (Dali::Toolkit::TableView *)jarg1;
82822   argp2 = (Dali::Actor *)jarg2;
82823   if (!argp2) {
82824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82825     return 0;
82826   }
82827   arg2 = *argp2;
82828   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82829   if (!argp3) {
82830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82831     return 0;
82832   }
82833   arg3 = *argp3;
82834   {
82835     try {
82836       result = (bool)(arg1)->AddChild(arg2,arg3);
82837     } catch (std::out_of_range& e) {
82838       {
82839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82840       };
82841     } catch (std::exception& e) {
82842       {
82843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82844       };
82845     } catch (Dali::DaliException e) {
82846       {
82847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82848       };
82849     } catch (...) {
82850       {
82851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82852       };
82853     }
82854   }
82855
82856   jresult = result;
82857   return jresult;
82858 }
82859
82860
82861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82862   void * jresult ;
82863   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82864   Dali::Toolkit::TableView::CellPosition arg2 ;
82865   Dali::Toolkit::TableView::CellPosition *argp2 ;
82866   Dali::Actor result;
82867
82868   arg1 = (Dali::Toolkit::TableView *)jarg1;
82869   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82870   if (!argp2) {
82871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82872     return 0;
82873   }
82874   arg2 = *argp2;
82875   {
82876     try {
82877       result = (arg1)->GetChildAt(arg2);
82878     } catch (std::out_of_range& e) {
82879       {
82880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82881       };
82882     } catch (std::exception& e) {
82883       {
82884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82885       };
82886     } catch (Dali::DaliException e) {
82887       {
82888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82889       };
82890     } catch (...) {
82891       {
82892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82893       };
82894     }
82895   }
82896
82897   jresult = new Dali::Actor((const Dali::Actor &)result);
82898   return jresult;
82899 }
82900
82901
82902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82903   void * jresult ;
82904   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82905   Dali::Toolkit::TableView::CellPosition arg2 ;
82906   Dali::Toolkit::TableView::CellPosition *argp2 ;
82907   Dali::Actor result;
82908
82909   arg1 = (Dali::Toolkit::TableView *)jarg1;
82910   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82911   if (!argp2) {
82912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82913     return 0;
82914   }
82915   arg2 = *argp2;
82916   {
82917     try {
82918       result = (arg1)->RemoveChildAt(arg2);
82919     } catch (std::out_of_range& e) {
82920       {
82921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82922       };
82923     } catch (std::exception& e) {
82924       {
82925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82926       };
82927     } catch (Dali::DaliException e) {
82928       {
82929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82930       };
82931     } catch (...) {
82932       {
82933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82934       };
82935     }
82936   }
82937
82938   jresult = new Dali::Actor((const Dali::Actor &)result);
82939   return jresult;
82940 }
82941
82942
82943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82944   unsigned int jresult ;
82945   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82946   Dali::Actor arg2 ;
82947   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82948   Dali::Actor *argp2 ;
82949   bool result;
82950
82951   arg1 = (Dali::Toolkit::TableView *)jarg1;
82952   argp2 = (Dali::Actor *)jarg2;
82953   if (!argp2) {
82954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82955     return 0;
82956   }
82957   arg2 = *argp2;
82958   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82959   if (!arg3) {
82960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82961     return 0;
82962   }
82963   {
82964     try {
82965       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82966     } catch (std::out_of_range& e) {
82967       {
82968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82969       };
82970     } catch (std::exception& e) {
82971       {
82972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82973       };
82974     } catch (Dali::DaliException e) {
82975       {
82976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82977       };
82978     } catch (...) {
82979       {
82980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82981       };
82982     }
82983   }
82984
82985   jresult = result;
82986   return jresult;
82987 }
82988
82989
82990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82991   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82992   unsigned int arg2 ;
82993
82994   arg1 = (Dali::Toolkit::TableView *)jarg1;
82995   arg2 = (unsigned int)jarg2;
82996   {
82997     try {
82998       (arg1)->InsertRow(arg2);
82999     } catch (std::out_of_range& e) {
83000       {
83001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83002       };
83003     } catch (std::exception& e) {
83004       {
83005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83006       };
83007     } catch (Dali::DaliException e) {
83008       {
83009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83010       };
83011     } catch (...) {
83012       {
83013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83014       };
83015     }
83016   }
83017
83018 }
83019
83020
83021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83022   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83023   unsigned int arg2 ;
83024
83025   arg1 = (Dali::Toolkit::TableView *)jarg1;
83026   arg2 = (unsigned int)jarg2;
83027   {
83028     try {
83029       (arg1)->DeleteRow(arg2);
83030     } catch (std::out_of_range& e) {
83031       {
83032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83033       };
83034     } catch (std::exception& e) {
83035       {
83036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83037       };
83038     } catch (Dali::DaliException e) {
83039       {
83040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83041       };
83042     } catch (...) {
83043       {
83044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83045       };
83046     }
83047   }
83048
83049 }
83050
83051
83052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83053   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83054   unsigned int arg2 ;
83055   std::vector< Dali::Actor > *arg3 = 0 ;
83056
83057   arg1 = (Dali::Toolkit::TableView *)jarg1;
83058   arg2 = (unsigned int)jarg2;
83059   arg3 = (std::vector< Dali::Actor > *)jarg3;
83060   if (!arg3) {
83061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83062     return ;
83063   }
83064   {
83065     try {
83066       (arg1)->DeleteRow(arg2,*arg3);
83067     } catch (std::out_of_range& e) {
83068       {
83069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83070       };
83071     } catch (std::exception& e) {
83072       {
83073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83074       };
83075     } catch (Dali::DaliException e) {
83076       {
83077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83078       };
83079     } catch (...) {
83080       {
83081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83082       };
83083     }
83084   }
83085
83086 }
83087
83088
83089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83090   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83091   unsigned int arg2 ;
83092
83093   arg1 = (Dali::Toolkit::TableView *)jarg1;
83094   arg2 = (unsigned int)jarg2;
83095   {
83096     try {
83097       (arg1)->InsertColumn(arg2);
83098     } catch (std::out_of_range& e) {
83099       {
83100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83101       };
83102     } catch (std::exception& e) {
83103       {
83104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83105       };
83106     } catch (Dali::DaliException e) {
83107       {
83108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83109       };
83110     } catch (...) {
83111       {
83112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83113       };
83114     }
83115   }
83116
83117 }
83118
83119
83120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83121   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83122   unsigned int arg2 ;
83123
83124   arg1 = (Dali::Toolkit::TableView *)jarg1;
83125   arg2 = (unsigned int)jarg2;
83126   {
83127     try {
83128       (arg1)->DeleteColumn(arg2);
83129     } catch (std::out_of_range& e) {
83130       {
83131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83132       };
83133     } catch (std::exception& e) {
83134       {
83135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83136       };
83137     } catch (Dali::DaliException e) {
83138       {
83139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83140       };
83141     } catch (...) {
83142       {
83143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83144       };
83145     }
83146   }
83147
83148 }
83149
83150
83151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83152   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83153   unsigned int arg2 ;
83154   std::vector< Dali::Actor > *arg3 = 0 ;
83155
83156   arg1 = (Dali::Toolkit::TableView *)jarg1;
83157   arg2 = (unsigned int)jarg2;
83158   arg3 = (std::vector< Dali::Actor > *)jarg3;
83159   if (!arg3) {
83160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83161     return ;
83162   }
83163   {
83164     try {
83165       (arg1)->DeleteColumn(arg2,*arg3);
83166     } catch (std::out_of_range& e) {
83167       {
83168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83169       };
83170     } catch (std::exception& e) {
83171       {
83172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83173       };
83174     } catch (Dali::DaliException e) {
83175       {
83176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83177       };
83178     } catch (...) {
83179       {
83180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83181       };
83182     }
83183   }
83184
83185 }
83186
83187
83188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83189   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83190   unsigned int arg2 ;
83191   unsigned int arg3 ;
83192
83193   arg1 = (Dali::Toolkit::TableView *)jarg1;
83194   arg2 = (unsigned int)jarg2;
83195   arg3 = (unsigned int)jarg3;
83196   {
83197     try {
83198       (arg1)->Resize(arg2,arg3);
83199     } catch (std::out_of_range& e) {
83200       {
83201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83202       };
83203     } catch (std::exception& e) {
83204       {
83205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83206       };
83207     } catch (Dali::DaliException e) {
83208       {
83209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83210       };
83211     } catch (...) {
83212       {
83213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83214       };
83215     }
83216   }
83217
83218 }
83219
83220
83221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83222   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83223   unsigned int arg2 ;
83224   unsigned int arg3 ;
83225   std::vector< Dali::Actor > *arg4 = 0 ;
83226
83227   arg1 = (Dali::Toolkit::TableView *)jarg1;
83228   arg2 = (unsigned int)jarg2;
83229   arg3 = (unsigned int)jarg3;
83230   arg4 = (std::vector< Dali::Actor > *)jarg4;
83231   if (!arg4) {
83232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83233     return ;
83234   }
83235   {
83236     try {
83237       (arg1)->Resize(arg2,arg3,*arg4);
83238     } catch (std::out_of_range& e) {
83239       {
83240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83241       };
83242     } catch (std::exception& e) {
83243       {
83244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83245       };
83246     } catch (Dali::DaliException e) {
83247       {
83248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83249       };
83250     } catch (...) {
83251       {
83252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83253       };
83254     }
83255   }
83256
83257 }
83258
83259
83260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83261   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83262   Dali::Size arg2 ;
83263   Dali::Size *argp2 ;
83264
83265   arg1 = (Dali::Toolkit::TableView *)jarg1;
83266   argp2 = (Dali::Size *)jarg2;
83267   if (!argp2) {
83268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83269     return ;
83270   }
83271   arg2 = *argp2;
83272   {
83273     try {
83274       (arg1)->SetCellPadding(arg2);
83275     } catch (std::out_of_range& e) {
83276       {
83277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83278       };
83279     } catch (std::exception& e) {
83280       {
83281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83282       };
83283     } catch (Dali::DaliException e) {
83284       {
83285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83286       };
83287     } catch (...) {
83288       {
83289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83290       };
83291     }
83292   }
83293
83294 }
83295
83296
83297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83298   void * jresult ;
83299   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83300   Dali::Size result;
83301
83302   arg1 = (Dali::Toolkit::TableView *)jarg1;
83303   {
83304     try {
83305       result = (arg1)->GetCellPadding();
83306     } catch (std::out_of_range& e) {
83307       {
83308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83309       };
83310     } catch (std::exception& e) {
83311       {
83312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83313       };
83314     } catch (Dali::DaliException e) {
83315       {
83316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83317       };
83318     } catch (...) {
83319       {
83320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83321       };
83322     }
83323   }
83324
83325   jresult = new Dali::Size((const Dali::Size &)result);
83326   return jresult;
83327 }
83328
83329
83330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83331   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83332   unsigned int arg2 ;
83333
83334   arg1 = (Dali::Toolkit::TableView *)jarg1;
83335   arg2 = (unsigned int)jarg2;
83336   {
83337     try {
83338       (arg1)->SetFitHeight(arg2);
83339     } catch (std::out_of_range& e) {
83340       {
83341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83342       };
83343     } catch (std::exception& e) {
83344       {
83345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83346       };
83347     } catch (Dali::DaliException e) {
83348       {
83349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83350       };
83351     } catch (...) {
83352       {
83353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83354       };
83355     }
83356   }
83357
83358 }
83359
83360
83361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83362   unsigned int jresult ;
83363   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83364   unsigned int arg2 ;
83365   bool result;
83366
83367   arg1 = (Dali::Toolkit::TableView *)jarg1;
83368   arg2 = (unsigned int)jarg2;
83369   {
83370     try {
83371       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83372     } catch (std::out_of_range& e) {
83373       {
83374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83375       };
83376     } catch (std::exception& e) {
83377       {
83378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83379       };
83380     } catch (Dali::DaliException e) {
83381       {
83382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83383       };
83384     } catch (...) {
83385       {
83386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83387       };
83388     }
83389   }
83390
83391   jresult = result;
83392   return jresult;
83393 }
83394
83395
83396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83397   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83398   unsigned int arg2 ;
83399
83400   arg1 = (Dali::Toolkit::TableView *)jarg1;
83401   arg2 = (unsigned int)jarg2;
83402   {
83403     try {
83404       (arg1)->SetFitWidth(arg2);
83405     } catch (std::out_of_range& e) {
83406       {
83407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83408       };
83409     } catch (std::exception& e) {
83410       {
83411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83412       };
83413     } catch (Dali::DaliException e) {
83414       {
83415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83416       };
83417     } catch (...) {
83418       {
83419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83420       };
83421     }
83422   }
83423
83424 }
83425
83426
83427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83428   unsigned int jresult ;
83429   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83430   unsigned int arg2 ;
83431   bool result;
83432
83433   arg1 = (Dali::Toolkit::TableView *)jarg1;
83434   arg2 = (unsigned int)jarg2;
83435   {
83436     try {
83437       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83438     } catch (std::out_of_range& e) {
83439       {
83440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83441       };
83442     } catch (std::exception& e) {
83443       {
83444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83445       };
83446     } catch (Dali::DaliException e) {
83447       {
83448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83449       };
83450     } catch (...) {
83451       {
83452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83453       };
83454     }
83455   }
83456
83457   jresult = result;
83458   return jresult;
83459 }
83460
83461
83462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83463   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83464   unsigned int arg2 ;
83465   float arg3 ;
83466
83467   arg1 = (Dali::Toolkit::TableView *)jarg1;
83468   arg2 = (unsigned int)jarg2;
83469   arg3 = (float)jarg3;
83470   {
83471     try {
83472       (arg1)->SetFixedHeight(arg2,arg3);
83473     } catch (std::out_of_range& e) {
83474       {
83475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83476       };
83477     } catch (std::exception& e) {
83478       {
83479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83480       };
83481     } catch (Dali::DaliException e) {
83482       {
83483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83484       };
83485     } catch (...) {
83486       {
83487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83488       };
83489     }
83490   }
83491
83492 }
83493
83494
83495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83496   float jresult ;
83497   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83498   unsigned int arg2 ;
83499   float result;
83500
83501   arg1 = (Dali::Toolkit::TableView *)jarg1;
83502   arg2 = (unsigned int)jarg2;
83503   {
83504     try {
83505       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83506     } catch (std::out_of_range& e) {
83507       {
83508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83509       };
83510     } catch (std::exception& e) {
83511       {
83512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83513       };
83514     } catch (Dali::DaliException e) {
83515       {
83516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83517       };
83518     } catch (...) {
83519       {
83520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83521       };
83522     }
83523   }
83524
83525   jresult = result;
83526   return jresult;
83527 }
83528
83529
83530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83531   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83532   unsigned int arg2 ;
83533   float arg3 ;
83534
83535   arg1 = (Dali::Toolkit::TableView *)jarg1;
83536   arg2 = (unsigned int)jarg2;
83537   arg3 = (float)jarg3;
83538   {
83539     try {
83540       (arg1)->SetRelativeHeight(arg2,arg3);
83541     } catch (std::out_of_range& e) {
83542       {
83543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83544       };
83545     } catch (std::exception& e) {
83546       {
83547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83548       };
83549     } catch (Dali::DaliException e) {
83550       {
83551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83552       };
83553     } catch (...) {
83554       {
83555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83556       };
83557     }
83558   }
83559
83560 }
83561
83562
83563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83564   float jresult ;
83565   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83566   unsigned int arg2 ;
83567   float result;
83568
83569   arg1 = (Dali::Toolkit::TableView *)jarg1;
83570   arg2 = (unsigned int)jarg2;
83571   {
83572     try {
83573       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83574     } catch (std::out_of_range& e) {
83575       {
83576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83577       };
83578     } catch (std::exception& e) {
83579       {
83580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83581       };
83582     } catch (Dali::DaliException e) {
83583       {
83584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83585       };
83586     } catch (...) {
83587       {
83588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83589       };
83590     }
83591   }
83592
83593   jresult = result;
83594   return jresult;
83595 }
83596
83597
83598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83599   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83600   unsigned int arg2 ;
83601   float arg3 ;
83602
83603   arg1 = (Dali::Toolkit::TableView *)jarg1;
83604   arg2 = (unsigned int)jarg2;
83605   arg3 = (float)jarg3;
83606   {
83607     try {
83608       (arg1)->SetFixedWidth(arg2,arg3);
83609     } catch (std::out_of_range& e) {
83610       {
83611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83612       };
83613     } catch (std::exception& e) {
83614       {
83615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83616       };
83617     } catch (Dali::DaliException e) {
83618       {
83619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83620       };
83621     } catch (...) {
83622       {
83623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83624       };
83625     }
83626   }
83627
83628 }
83629
83630
83631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83632   float jresult ;
83633   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83634   unsigned int arg2 ;
83635   float result;
83636
83637   arg1 = (Dali::Toolkit::TableView *)jarg1;
83638   arg2 = (unsigned int)jarg2;
83639   {
83640     try {
83641       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83642     } catch (std::out_of_range& e) {
83643       {
83644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83645       };
83646     } catch (std::exception& e) {
83647       {
83648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83649       };
83650     } catch (Dali::DaliException e) {
83651       {
83652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83653       };
83654     } catch (...) {
83655       {
83656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83657       };
83658     }
83659   }
83660
83661   jresult = result;
83662   return jresult;
83663 }
83664
83665
83666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83667   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83668   unsigned int arg2 ;
83669   float arg3 ;
83670
83671   arg1 = (Dali::Toolkit::TableView *)jarg1;
83672   arg2 = (unsigned int)jarg2;
83673   arg3 = (float)jarg3;
83674   {
83675     try {
83676       (arg1)->SetRelativeWidth(arg2,arg3);
83677     } catch (std::out_of_range& e) {
83678       {
83679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83680       };
83681     } catch (std::exception& e) {
83682       {
83683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83684       };
83685     } catch (Dali::DaliException e) {
83686       {
83687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83688       };
83689     } catch (...) {
83690       {
83691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83692       };
83693     }
83694   }
83695
83696 }
83697
83698
83699 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83700   float jresult ;
83701   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83702   unsigned int arg2 ;
83703   float result;
83704
83705   arg1 = (Dali::Toolkit::TableView *)jarg1;
83706   arg2 = (unsigned int)jarg2;
83707   {
83708     try {
83709       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83710     } catch (std::out_of_range& e) {
83711       {
83712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83713       };
83714     } catch (std::exception& e) {
83715       {
83716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83717       };
83718     } catch (Dali::DaliException e) {
83719       {
83720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83721       };
83722     } catch (...) {
83723       {
83724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83725       };
83726     }
83727   }
83728
83729   jresult = result;
83730   return jresult;
83731 }
83732
83733
83734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83735   unsigned int jresult ;
83736   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83737   unsigned int result;
83738
83739   arg1 = (Dali::Toolkit::TableView *)jarg1;
83740   {
83741     try {
83742       result = (unsigned int)(arg1)->GetRows();
83743     } catch (std::out_of_range& e) {
83744       {
83745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83746       };
83747     } catch (std::exception& e) {
83748       {
83749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83750       };
83751     } catch (Dali::DaliException e) {
83752       {
83753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83754       };
83755     } catch (...) {
83756       {
83757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83758       };
83759     }
83760   }
83761
83762   jresult = result;
83763   return jresult;
83764 }
83765
83766
83767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83768   unsigned int jresult ;
83769   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83770   unsigned int result;
83771
83772   arg1 = (Dali::Toolkit::TableView *)jarg1;
83773   {
83774     try {
83775       result = (unsigned int)(arg1)->GetColumns();
83776     } catch (std::out_of_range& e) {
83777       {
83778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83779       };
83780     } catch (std::exception& e) {
83781       {
83782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83783       };
83784     } catch (Dali::DaliException e) {
83785       {
83786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83787       };
83788     } catch (...) {
83789       {
83790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83791       };
83792     }
83793   }
83794
83795   jresult = result;
83796   return jresult;
83797 }
83798
83799
83800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83801   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83802   Dali::Toolkit::TableView::CellPosition arg2 ;
83803   Dali::HorizontalAlignment::Type arg3 ;
83804   Dali::VerticalAlignment::Type arg4 ;
83805   Dali::Toolkit::TableView::CellPosition *argp2 ;
83806
83807   arg1 = (Dali::Toolkit::TableView *)jarg1;
83808   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83809   if (!argp2) {
83810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83811     return ;
83812   }
83813   arg2 = *argp2;
83814   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83815   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83816   {
83817     try {
83818       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83819     } catch (std::out_of_range& e) {
83820       {
83821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83822       };
83823     } catch (std::exception& e) {
83824       {
83825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83826       };
83827     } catch (Dali::DaliException e) {
83828       {
83829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83830       };
83831     } catch (...) {
83832       {
83833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83834       };
83835     }
83836   }
83837
83838 }
83839
83840
83841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83842   unsigned int jresult ;
83843   unsigned int result;
83844
83845   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83846   jresult = result;
83847   return jresult;
83848 }
83849
83850
83851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83852   int jresult ;
83853   int result;
83854
83855   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83856   jresult = (int)result;
83857   return jresult;
83858 }
83859
83860
83861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83862   int jresult ;
83863   int result;
83864
83865   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83866   jresult = (int)result;
83867   return jresult;
83868 }
83869
83870
83871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83872   int jresult ;
83873   int result;
83874
83875   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83876   jresult = (int)result;
83877   return jresult;
83878 }
83879
83880
83881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83882   int jresult ;
83883   int result;
83884
83885   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83886   jresult = (int)result;
83887   return jresult;
83888 }
83889
83890
83891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83892   int jresult ;
83893   int result;
83894
83895   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83896   jresult = (int)result;
83897   return jresult;
83898 }
83899
83900
83901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83902   int jresult ;
83903   int result;
83904
83905   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83906   jresult = (int)result;
83907   return jresult;
83908 }
83909
83910
83911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83912   int jresult ;
83913   int result;
83914
83915   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83916   jresult = (int)result;
83917   return jresult;
83918 }
83919
83920
83921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83922   int jresult ;
83923   int result;
83924
83925   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83926   jresult = (int)result;
83927   return jresult;
83928 }
83929
83930
83931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83932   int jresult ;
83933   int result;
83934
83935   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83936   jresult = (int)result;
83937   return jresult;
83938 }
83939
83940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
83941   int jresult ;
83942   int result;
83943
83944   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
83945   jresult = (int)result;
83946   return jresult;
83947 }
83948
83949
83950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
83951   int jresult ;
83952   int result;
83953
83954   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
83955   jresult = (int)result;
83956   return jresult;
83957 }
83958
83959
83960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
83961   int jresult ;
83962   int result;
83963
83964   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
83965   jresult = (int)result;
83966   return jresult;
83967 }
83968
83969
83970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
83971   int jresult ;
83972   int result;
83973
83974   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
83975   jresult = (int)result;
83976   return jresult;
83977 }
83978
83979
83980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
83981   int jresult ;
83982   int result;
83983
83984   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
83985   jresult = (int)result;
83986   return jresult;
83987 }
83988
83989
83990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83991   int jresult ;
83992   int result;
83993
83994   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83995   jresult = (int)result;
83996   return jresult;
83997 }
83998
83999
84000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84001   int jresult ;
84002   int result;
84003
84004   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84005   jresult = (int)result;
84006   return jresult;
84007 }
84008
84009
84010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84011   int jresult ;
84012   int result;
84013
84014   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84015   jresult = (int)result;
84016   return jresult;
84017 }
84018
84019
84020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84021   int jresult ;
84022   int result;
84023
84024   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84025   jresult = (int)result;
84026   return jresult;
84027 }
84028
84029
84030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84031   int jresult ;
84032   int result;
84033
84034   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84035   jresult = (int)result;
84036   return jresult;
84037 }
84038
84039
84040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84041   int jresult ;
84042   int result;
84043
84044   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84045   jresult = (int)result;
84046   return jresult;
84047 }
84048
84049
84050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84051   int jresult ;
84052   int result;
84053
84054   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84055   jresult = (int)result;
84056   return jresult;
84057 }
84058
84059
84060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84061   int jresult ;
84062   int result;
84063
84064   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84065   jresult = (int)result;
84066   return jresult;
84067 }
84068
84069
84070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84071   int jresult ;
84072   int result;
84073
84074   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84075   jresult = (int)result;
84076   return jresult;
84077 }
84078
84079
84080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84081   int jresult ;
84082   int result;
84083
84084   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84085   jresult = (int)result;
84086   return jresult;
84087 }
84088
84089
84090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84091   void * jresult ;
84092   Dali::Toolkit::TextLabel::Property *result = 0 ;
84093
84094   {
84095     try {
84096       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84097     } catch (std::out_of_range& e) {
84098       {
84099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84100       };
84101     } catch (std::exception& e) {
84102       {
84103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84104       };
84105     } catch (Dali::DaliException e) {
84106       {
84107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84108       };
84109     } catch (...) {
84110       {
84111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84112       };
84113     }
84114   }
84115
84116   jresult = (void *)result;
84117   return jresult;
84118 }
84119
84120
84121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84122   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84123
84124   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84125   {
84126     try {
84127       delete arg1;
84128     } catch (std::out_of_range& e) {
84129       {
84130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84131       };
84132     } catch (std::exception& e) {
84133       {
84134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84135       };
84136     } catch (Dali::DaliException e) {
84137       {
84138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84139       };
84140     } catch (...) {
84141       {
84142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84143       };
84144     }
84145   }
84146
84147 }
84148
84149
84150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84151   void * jresult ;
84152   Dali::Toolkit::TextLabel result;
84153
84154   {
84155     try {
84156       result = Dali::Toolkit::TextLabel::New();
84157     } catch (std::out_of_range& e) {
84158       {
84159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84160       };
84161     } catch (std::exception& e) {
84162       {
84163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84164       };
84165     } catch (Dali::DaliException e) {
84166       {
84167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84168       };
84169     } catch (...) {
84170       {
84171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84172       };
84173     }
84174   }
84175
84176   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84177   return jresult;
84178 }
84179
84180
84181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84182   void * jresult ;
84183   std::string *arg1 = 0 ;
84184   Dali::Toolkit::TextLabel result;
84185
84186   if (!jarg1) {
84187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84188     return 0;
84189   }
84190   std::string arg1_str(jarg1);
84191   arg1 = &arg1_str;
84192   {
84193     try {
84194       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84195     } catch (std::out_of_range& e) {
84196       {
84197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84198       };
84199     } catch (std::exception& e) {
84200       {
84201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84202       };
84203     } catch (Dali::DaliException e) {
84204       {
84205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84206       };
84207     } catch (...) {
84208       {
84209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84210       };
84211     }
84212   }
84213
84214   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84215
84216   //argout typemap for const std::string&
84217
84218   return jresult;
84219 }
84220
84221
84222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84223   void * jresult ;
84224   Dali::Toolkit::TextLabel *result = 0 ;
84225
84226   {
84227     try {
84228       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84229     } catch (std::out_of_range& e) {
84230       {
84231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84232       };
84233     } catch (std::exception& e) {
84234       {
84235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84236       };
84237     } catch (Dali::DaliException e) {
84238       {
84239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84240       };
84241     } catch (...) {
84242       {
84243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84244       };
84245     }
84246   }
84247
84248   jresult = (void *)result;
84249   return jresult;
84250 }
84251
84252
84253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84254   void * jresult ;
84255   Dali::Toolkit::TextLabel *arg1 = 0 ;
84256   Dali::Toolkit::TextLabel *result = 0 ;
84257
84258   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84259   if (!arg1) {
84260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84261     return 0;
84262   }
84263   {
84264     try {
84265       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84266     } catch (std::out_of_range& e) {
84267       {
84268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84269       };
84270     } catch (std::exception& e) {
84271       {
84272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84273       };
84274     } catch (Dali::DaliException e) {
84275       {
84276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84277       };
84278     } catch (...) {
84279       {
84280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84281       };
84282     }
84283   }
84284
84285   jresult = (void *)result;
84286   return jresult;
84287 }
84288
84289
84290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84291   void * jresult ;
84292   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84293   Dali::Toolkit::TextLabel *arg2 = 0 ;
84294   Dali::Toolkit::TextLabel *result = 0 ;
84295
84296   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84297   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84298   if (!arg2) {
84299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84300     return 0;
84301   }
84302   {
84303     try {
84304       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84305     } catch (std::out_of_range& e) {
84306       {
84307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84308       };
84309     } catch (std::exception& e) {
84310       {
84311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84312       };
84313     } catch (Dali::DaliException e) {
84314       {
84315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84316       };
84317     } catch (...) {
84318       {
84319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84320       };
84321     }
84322   }
84323
84324   jresult = (void *)result;
84325   return jresult;
84326 }
84327
84328
84329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84330   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84331
84332   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84333   {
84334     try {
84335       delete arg1;
84336     } catch (std::out_of_range& e) {
84337       {
84338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84339       };
84340     } catch (std::exception& e) {
84341       {
84342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84343       };
84344     } catch (Dali::DaliException e) {
84345       {
84346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84347       };
84348     } catch (...) {
84349       {
84350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84351       };
84352     }
84353   }
84354
84355 }
84356
84357
84358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84359   void * jresult ;
84360   Dali::BaseHandle arg1 ;
84361   Dali::BaseHandle *argp1 ;
84362   Dali::Toolkit::TextLabel result;
84363
84364   argp1 = (Dali::BaseHandle *)jarg1;
84365   if (!argp1) {
84366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84367     return 0;
84368   }
84369   arg1 = *argp1;
84370   {
84371     try {
84372       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84373     } catch (std::out_of_range& e) {
84374       {
84375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84376       };
84377     } catch (std::exception& e) {
84378       {
84379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84380       };
84381     } catch (Dali::DaliException e) {
84382       {
84383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84384       };
84385     } catch (...) {
84386       {
84387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84388       };
84389     }
84390   }
84391
84392   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84393   return jresult;
84394 }
84395
84396
84397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84398   void * jresult ;
84399   Dali::Toolkit::AccessibilityManager *result = 0 ;
84400
84401   {
84402     try {
84403       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84404     } catch (std::out_of_range& e) {
84405       {
84406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84407       };
84408     } catch (std::exception& e) {
84409       {
84410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84411       };
84412     } catch (Dali::DaliException e) {
84413       {
84414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84415       };
84416     } catch (...) {
84417       {
84418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84419       };
84420     }
84421   }
84422
84423   jresult = (void *)result;
84424   return jresult;
84425 }
84426
84427
84428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84429   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84430
84431   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84432   {
84433     try {
84434       delete arg1;
84435     } catch (std::out_of_range& e) {
84436       {
84437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84438       };
84439     } catch (std::exception& e) {
84440       {
84441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84442       };
84443     } catch (Dali::DaliException e) {
84444       {
84445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84446       };
84447     } catch (...) {
84448       {
84449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84450       };
84451     }
84452   }
84453
84454 }
84455
84456
84457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84458   void * jresult ;
84459   Dali::Toolkit::AccessibilityManager result;
84460
84461   {
84462     try {
84463       result = Dali::Toolkit::AccessibilityManager::Get();
84464     } catch (std::out_of_range& e) {
84465       {
84466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84467       };
84468     } catch (std::exception& e) {
84469       {
84470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84471       };
84472     } catch (Dali::DaliException e) {
84473       {
84474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84475       };
84476     } catch (...) {
84477       {
84478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84479       };
84480     }
84481   }
84482
84483   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84484   return jresult;
84485 }
84486
84487
84488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84489   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84490   Dali::Actor arg2 ;
84491   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84492   std::string *arg4 = 0 ;
84493   Dali::Actor *argp2 ;
84494
84495   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84496   argp2 = (Dali::Actor *)jarg2;
84497   if (!argp2) {
84498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84499     return ;
84500   }
84501   arg2 = *argp2;
84502   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84503   if (!jarg4) {
84504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84505     return ;
84506   }
84507   std::string arg4_str(jarg4);
84508   arg4 = &arg4_str;
84509   {
84510     try {
84511       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84512     } catch (std::out_of_range& e) {
84513       {
84514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84515       };
84516     } catch (std::exception& e) {
84517       {
84518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84519       };
84520     } catch (Dali::DaliException e) {
84521       {
84522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84523       };
84524     } catch (...) {
84525       {
84526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84527       };
84528     }
84529   }
84530
84531
84532   //argout typemap for const std::string&
84533
84534 }
84535
84536
84537 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84538   char * jresult ;
84539   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84540   Dali::Actor arg2 ;
84541   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84542   Dali::Actor *argp2 ;
84543   std::string result;
84544
84545   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84546   argp2 = (Dali::Actor *)jarg2;
84547   if (!argp2) {
84548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84549     return 0;
84550   }
84551   arg2 = *argp2;
84552   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84553   {
84554     try {
84555       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84556     } catch (std::out_of_range& e) {
84557       {
84558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84559       };
84560     } catch (std::exception& e) {
84561       {
84562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84563       };
84564     } catch (Dali::DaliException e) {
84565       {
84566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84567       };
84568     } catch (...) {
84569       {
84570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84571       };
84572     }
84573   }
84574
84575   jresult = SWIG_csharp_string_callback((&result)->c_str());
84576   return jresult;
84577 }
84578
84579
84580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84581   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84582   Dali::Actor arg2 ;
84583   unsigned int arg3 ;
84584   Dali::Actor *argp2 ;
84585
84586   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84587   argp2 = (Dali::Actor *)jarg2;
84588   if (!argp2) {
84589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84590     return ;
84591   }
84592   arg2 = *argp2;
84593   arg3 = (unsigned int)jarg3;
84594   {
84595     try {
84596       (arg1)->SetFocusOrder(arg2,arg3);
84597     } catch (std::out_of_range& e) {
84598       {
84599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84600       };
84601     } catch (std::exception& e) {
84602       {
84603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84604       };
84605     } catch (Dali::DaliException e) {
84606       {
84607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84608       };
84609     } catch (...) {
84610       {
84611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84612       };
84613     }
84614   }
84615
84616 }
84617
84618
84619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84620   unsigned int jresult ;
84621   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84622   Dali::Actor arg2 ;
84623   Dali::Actor *argp2 ;
84624   unsigned int result;
84625
84626   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84627   argp2 = (Dali::Actor *)jarg2;
84628   if (!argp2) {
84629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84630     return 0;
84631   }
84632   arg2 = *argp2;
84633   {
84634     try {
84635       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84636     } catch (std::out_of_range& e) {
84637       {
84638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84639       };
84640     } catch (std::exception& e) {
84641       {
84642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84643       };
84644     } catch (Dali::DaliException e) {
84645       {
84646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84647       };
84648     } catch (...) {
84649       {
84650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84651       };
84652     }
84653   }
84654
84655   jresult = result;
84656   return jresult;
84657 }
84658
84659
84660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84661   unsigned int jresult ;
84662   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84663   unsigned int result;
84664
84665   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84666   {
84667     try {
84668       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84669     } catch (std::out_of_range& e) {
84670       {
84671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84672       };
84673     } catch (std::exception& e) {
84674       {
84675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84676       };
84677     } catch (Dali::DaliException e) {
84678       {
84679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84680       };
84681     } catch (...) {
84682       {
84683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84684       };
84685     }
84686   }
84687
84688   jresult = result;
84689   return jresult;
84690 }
84691
84692
84693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84694   void * jresult ;
84695   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84696   unsigned int arg2 ;
84697   Dali::Actor result;
84698
84699   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84700   arg2 = (unsigned int)jarg2;
84701   {
84702     try {
84703       result = (arg1)->GetActorByFocusOrder(arg2);
84704     } catch (std::out_of_range& e) {
84705       {
84706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84707       };
84708     } catch (std::exception& e) {
84709       {
84710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84711       };
84712     } catch (Dali::DaliException e) {
84713       {
84714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84715       };
84716     } catch (...) {
84717       {
84718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84719       };
84720     }
84721   }
84722
84723   jresult = new Dali::Actor((const Dali::Actor &)result);
84724   return jresult;
84725 }
84726
84727
84728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84729   unsigned int jresult ;
84730   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84731   Dali::Actor arg2 ;
84732   Dali::Actor *argp2 ;
84733   bool result;
84734
84735   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84736   argp2 = (Dali::Actor *)jarg2;
84737   if (!argp2) {
84738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84739     return 0;
84740   }
84741   arg2 = *argp2;
84742   {
84743     try {
84744       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84745     } catch (std::out_of_range& e) {
84746       {
84747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84748       };
84749     } catch (std::exception& e) {
84750       {
84751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84752       };
84753     } catch (Dali::DaliException e) {
84754       {
84755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84756       };
84757     } catch (...) {
84758       {
84759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84760       };
84761     }
84762   }
84763
84764   jresult = result;
84765   return jresult;
84766 }
84767
84768
84769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84770   void * jresult ;
84771   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84772   Dali::Actor result;
84773
84774   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84775   {
84776     try {
84777       result = (arg1)->GetCurrentFocusActor();
84778     } catch (std::out_of_range& e) {
84779       {
84780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84781       };
84782     } catch (std::exception& e) {
84783       {
84784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84785       };
84786     } catch (Dali::DaliException e) {
84787       {
84788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84789       };
84790     } catch (...) {
84791       {
84792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84793       };
84794     }
84795   }
84796
84797   jresult = new Dali::Actor((const Dali::Actor &)result);
84798   return jresult;
84799 }
84800
84801
84802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84803   void * jresult ;
84804   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84805   Dali::Actor result;
84806
84807   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84808   {
84809     try {
84810       result = (arg1)->GetCurrentFocusGroup();
84811     } catch (std::out_of_range& e) {
84812       {
84813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84814       };
84815     } catch (std::exception& e) {
84816       {
84817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84818       };
84819     } catch (Dali::DaliException e) {
84820       {
84821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84822       };
84823     } catch (...) {
84824       {
84825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84826       };
84827     }
84828   }
84829
84830   jresult = new Dali::Actor((const Dali::Actor &)result);
84831   return jresult;
84832 }
84833
84834
84835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84836   unsigned int jresult ;
84837   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84838   unsigned int result;
84839
84840   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84841   {
84842     try {
84843       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84844     } catch (std::out_of_range& e) {
84845       {
84846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84847       };
84848     } catch (std::exception& e) {
84849       {
84850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84851       };
84852     } catch (Dali::DaliException e) {
84853       {
84854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84855       };
84856     } catch (...) {
84857       {
84858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84859       };
84860     }
84861   }
84862
84863   jresult = result;
84864   return jresult;
84865 }
84866
84867
84868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84869   unsigned int jresult ;
84870   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84871   bool result;
84872
84873   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84874   {
84875     try {
84876       result = (bool)(arg1)->MoveFocusForward();
84877     } catch (std::out_of_range& e) {
84878       {
84879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84880       };
84881     } catch (std::exception& e) {
84882       {
84883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84884       };
84885     } catch (Dali::DaliException e) {
84886       {
84887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84888       };
84889     } catch (...) {
84890       {
84891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84892       };
84893     }
84894   }
84895
84896   jresult = result;
84897   return jresult;
84898 }
84899
84900
84901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84902   unsigned int jresult ;
84903   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84904   bool result;
84905
84906   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84907   {
84908     try {
84909       result = (bool)(arg1)->MoveFocusBackward();
84910     } catch (std::out_of_range& e) {
84911       {
84912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84913       };
84914     } catch (std::exception& e) {
84915       {
84916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84917       };
84918     } catch (Dali::DaliException e) {
84919       {
84920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84921       };
84922     } catch (...) {
84923       {
84924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84925       };
84926     }
84927   }
84928
84929   jresult = result;
84930   return jresult;
84931 }
84932
84933
84934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84935   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84936
84937   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84938   {
84939     try {
84940       (arg1)->ClearFocus();
84941     } catch (std::out_of_range& e) {
84942       {
84943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84944       };
84945     } catch (std::exception& e) {
84946       {
84947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84948       };
84949     } catch (Dali::DaliException e) {
84950       {
84951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84952       };
84953     } catch (...) {
84954       {
84955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84956       };
84957     }
84958   }
84959
84960 }
84961
84962
84963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84964   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84965
84966   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84967   {
84968     try {
84969       (arg1)->Reset();
84970     } catch (std::out_of_range& e) {
84971       {
84972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84973       };
84974     } catch (std::exception& e) {
84975       {
84976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84977       };
84978     } catch (Dali::DaliException e) {
84979       {
84980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84981       };
84982     } catch (...) {
84983       {
84984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84985       };
84986     }
84987   }
84988
84989 }
84990
84991
84992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
84993   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84994   Dali::Actor arg2 ;
84995   bool arg3 ;
84996   Dali::Actor *argp2 ;
84997
84998   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84999   argp2 = (Dali::Actor *)jarg2;
85000   if (!argp2) {
85001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85002     return ;
85003   }
85004   arg2 = *argp2;
85005   arg3 = jarg3 ? true : false;
85006   {
85007     try {
85008       (arg1)->SetFocusGroup(arg2,arg3);
85009     } catch (std::out_of_range& e) {
85010       {
85011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85012       };
85013     } catch (std::exception& e) {
85014       {
85015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85016       };
85017     } catch (Dali::DaliException e) {
85018       {
85019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85020       };
85021     } catch (...) {
85022       {
85023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85024       };
85025     }
85026   }
85027
85028 }
85029
85030
85031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85032   unsigned int jresult ;
85033   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85034   Dali::Actor arg2 ;
85035   Dali::Actor *argp2 ;
85036   bool result;
85037
85038   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85039   argp2 = (Dali::Actor *)jarg2;
85040   if (!argp2) {
85041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85042     return 0;
85043   }
85044   arg2 = *argp2;
85045   {
85046     try {
85047       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85048     } catch (std::out_of_range& e) {
85049       {
85050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85051       };
85052     } catch (std::exception& e) {
85053       {
85054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85055       };
85056     } catch (Dali::DaliException e) {
85057       {
85058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85059       };
85060     } catch (...) {
85061       {
85062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85063       };
85064     }
85065   }
85066
85067   jresult = result;
85068   return jresult;
85069 }
85070
85071
85072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85073   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85074   bool arg2 ;
85075
85076   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85077   arg2 = jarg2 ? true : false;
85078   {
85079     try {
85080       (arg1)->SetGroupMode(arg2);
85081     } catch (std::out_of_range& e) {
85082       {
85083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85084       };
85085     } catch (std::exception& e) {
85086       {
85087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85088       };
85089     } catch (Dali::DaliException e) {
85090       {
85091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85092       };
85093     } catch (...) {
85094       {
85095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85096       };
85097     }
85098   }
85099
85100 }
85101
85102
85103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85104   unsigned int jresult ;
85105   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85106   bool result;
85107
85108   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85109   {
85110     try {
85111       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85112     } catch (std::out_of_range& e) {
85113       {
85114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85115       };
85116     } catch (std::exception& e) {
85117       {
85118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85119       };
85120     } catch (Dali::DaliException e) {
85121       {
85122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85123       };
85124     } catch (...) {
85125       {
85126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85127       };
85128     }
85129   }
85130
85131   jresult = result;
85132   return jresult;
85133 }
85134
85135
85136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85137   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85138   bool arg2 ;
85139
85140   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85141   arg2 = jarg2 ? true : false;
85142   {
85143     try {
85144       (arg1)->SetWrapMode(arg2);
85145     } catch (std::out_of_range& e) {
85146       {
85147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85148       };
85149     } catch (std::exception& e) {
85150       {
85151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85152       };
85153     } catch (Dali::DaliException e) {
85154       {
85155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85156       };
85157     } catch (...) {
85158       {
85159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85160       };
85161     }
85162   }
85163
85164 }
85165
85166
85167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85168   unsigned int jresult ;
85169   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85170   bool result;
85171
85172   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85173   {
85174     try {
85175       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85176     } catch (std::out_of_range& e) {
85177       {
85178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85179       };
85180     } catch (std::exception& e) {
85181       {
85182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85183       };
85184     } catch (Dali::DaliException e) {
85185       {
85186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85187       };
85188     } catch (...) {
85189       {
85190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85191       };
85192     }
85193   }
85194
85195   jresult = result;
85196   return jresult;
85197 }
85198
85199
85200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85201   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85202   Dali::Actor arg2 ;
85203   Dali::Actor *argp2 ;
85204
85205   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85206   argp2 = (Dali::Actor *)jarg2;
85207   if (!argp2) {
85208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85209     return ;
85210   }
85211   arg2 = *argp2;
85212   {
85213     try {
85214       (arg1)->SetFocusIndicatorActor(arg2);
85215     } catch (std::out_of_range& e) {
85216       {
85217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85218       };
85219     } catch (std::exception& e) {
85220       {
85221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85222       };
85223     } catch (Dali::DaliException e) {
85224       {
85225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85226       };
85227     } catch (...) {
85228       {
85229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85230       };
85231     }
85232   }
85233
85234 }
85235
85236
85237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85238   void * jresult ;
85239   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85240   Dali::Actor result;
85241
85242   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85243   {
85244     try {
85245       result = (arg1)->GetFocusIndicatorActor();
85246     } catch (std::out_of_range& e) {
85247       {
85248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85249       };
85250     } catch (std::exception& e) {
85251       {
85252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85253       };
85254     } catch (Dali::DaliException e) {
85255       {
85256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85257       };
85258     } catch (...) {
85259       {
85260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85261       };
85262     }
85263   }
85264
85265   jresult = new Dali::Actor((const Dali::Actor &)result);
85266   return jresult;
85267 }
85268
85269
85270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85271   void * jresult ;
85272   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85273   Dali::Actor arg2 ;
85274   Dali::Actor *argp2 ;
85275   Dali::Actor result;
85276
85277   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85278   argp2 = (Dali::Actor *)jarg2;
85279   if (!argp2) {
85280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85281     return 0;
85282   }
85283   arg2 = *argp2;
85284   {
85285     try {
85286       result = (arg1)->GetFocusGroup(arg2);
85287     } catch (std::out_of_range& e) {
85288       {
85289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85290       };
85291     } catch (std::exception& e) {
85292       {
85293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85294       };
85295     } catch (Dali::DaliException e) {
85296       {
85297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85298       };
85299     } catch (...) {
85300       {
85301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85302       };
85303     }
85304   }
85305
85306   jresult = new Dali::Actor((const Dali::Actor &)result);
85307   return jresult;
85308 }
85309
85310
85311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85312   void * jresult ;
85313   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85314   Dali::Vector2 result;
85315
85316   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85317   {
85318     try {
85319       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85320     } catch (std::out_of_range& e) {
85321       {
85322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85323       };
85324     } catch (std::exception& e) {
85325       {
85326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85327       };
85328     } catch (Dali::DaliException e) {
85329       {
85330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85331       };
85332     } catch (...) {
85333       {
85334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85335       };
85336     }
85337   }
85338
85339   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85340   return jresult;
85341 }
85342
85343
85344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85345   void * jresult ;
85346   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85347   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85348
85349   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85350   {
85351     try {
85352       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85353     } catch (std::out_of_range& e) {
85354       {
85355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85356       };
85357     } catch (std::exception& e) {
85358       {
85359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85360       };
85361     } catch (Dali::DaliException e) {
85362       {
85363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85364       };
85365     } catch (...) {
85366       {
85367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85368       };
85369     }
85370   }
85371
85372   jresult = (void *)result;
85373   return jresult;
85374 }
85375
85376
85377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85378   void * jresult ;
85379   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85380   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85381
85382   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85383   {
85384     try {
85385       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85386     } catch (std::out_of_range& e) {
85387       {
85388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85389       };
85390     } catch (std::exception& e) {
85391       {
85392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85393       };
85394     } catch (Dali::DaliException e) {
85395       {
85396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85397       };
85398     } catch (...) {
85399       {
85400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85401       };
85402     }
85403   }
85404
85405   jresult = (void *)result;
85406   return jresult;
85407 }
85408
85409
85410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85411   void * jresult ;
85412   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85413   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85414
85415   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85416   {
85417     try {
85418       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85419     } catch (std::out_of_range& e) {
85420       {
85421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85422       };
85423     } catch (std::exception& e) {
85424       {
85425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85426       };
85427     } catch (Dali::DaliException e) {
85428       {
85429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85430       };
85431     } catch (...) {
85432       {
85433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85434       };
85435     }
85436   }
85437
85438   jresult = (void *)result;
85439   return jresult;
85440 }
85441
85442
85443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85444   void * jresult ;
85445   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85446   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85447
85448   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85449   {
85450     try {
85451       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85452     } catch (std::out_of_range& e) {
85453       {
85454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85455       };
85456     } catch (std::exception& e) {
85457       {
85458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85459       };
85460     } catch (Dali::DaliException e) {
85461       {
85462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85463       };
85464     } catch (...) {
85465       {
85466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85467       };
85468     }
85469   }
85470
85471   jresult = (void *)result;
85472   return jresult;
85473 }
85474
85475
85476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85477   void * jresult ;
85478   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85479   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85480
85481   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85482   {
85483     try {
85484       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85485     } catch (std::out_of_range& e) {
85486       {
85487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85488       };
85489     } catch (std::exception& e) {
85490       {
85491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85492       };
85493     } catch (Dali::DaliException e) {
85494       {
85495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85496       };
85497     } catch (...) {
85498       {
85499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85500       };
85501     }
85502   }
85503
85504   jresult = (void *)result;
85505   return jresult;
85506 }
85507
85508
85509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85510   void * jresult ;
85511   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85512   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85513
85514   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85515   {
85516     try {
85517       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85518     } catch (std::out_of_range& e) {
85519       {
85520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85521       };
85522     } catch (std::exception& e) {
85523       {
85524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85525       };
85526     } catch (Dali::DaliException e) {
85527       {
85528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85529       };
85530     } catch (...) {
85531       {
85532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85533       };
85534     }
85535   }
85536
85537   jresult = (void *)result;
85538   return jresult;
85539 }
85540
85541
85542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85543   void * jresult ;
85544   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85545   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85546
85547   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85548   {
85549     try {
85550       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85551     } catch (std::out_of_range& e) {
85552       {
85553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85554       };
85555     } catch (std::exception& e) {
85556       {
85557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85558       };
85559     } catch (Dali::DaliException e) {
85560       {
85561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85562       };
85563     } catch (...) {
85564       {
85565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85566       };
85567     }
85568   }
85569
85570   jresult = (void *)result;
85571   return jresult;
85572 }
85573
85574
85575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85576   void * jresult ;
85577   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85578   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85579
85580   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85581   {
85582     try {
85583       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85584     } catch (std::out_of_range& e) {
85585       {
85586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85587       };
85588     } catch (std::exception& e) {
85589       {
85590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85591       };
85592     } catch (Dali::DaliException e) {
85593       {
85594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85595       };
85596     } catch (...) {
85597       {
85598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85599       };
85600     }
85601   }
85602
85603   jresult = (void *)result;
85604   return jresult;
85605 }
85606
85607
85608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85609   void * jresult ;
85610   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85611   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85612
85613   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85614   {
85615     try {
85616       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85617     } catch (std::out_of_range& e) {
85618       {
85619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85620       };
85621     } catch (std::exception& e) {
85622       {
85623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85624       };
85625     } catch (Dali::DaliException e) {
85626       {
85627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85628       };
85629     } catch (...) {
85630       {
85631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85632       };
85633     }
85634   }
85635
85636   jresult = (void *)result;
85637   return jresult;
85638 }
85639
85640
85641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85642   void * jresult ;
85643   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85644   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85645
85646   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85647   {
85648     try {
85649       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85650     } catch (std::out_of_range& e) {
85651       {
85652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85653       };
85654     } catch (std::exception& e) {
85655       {
85656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85657       };
85658     } catch (Dali::DaliException e) {
85659       {
85660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85661       };
85662     } catch (...) {
85663       {
85664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85665       };
85666     }
85667   }
85668
85669   jresult = (void *)result;
85670   return jresult;
85671 }
85672
85673
85674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85675   void * jresult ;
85676   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85677   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85678
85679   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85680   {
85681     try {
85682       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85683     } catch (std::out_of_range& e) {
85684       {
85685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85686       };
85687     } catch (std::exception& e) {
85688       {
85689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85690       };
85691     } catch (Dali::DaliException e) {
85692       {
85693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85694       };
85695     } catch (...) {
85696       {
85697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85698       };
85699     }
85700   }
85701
85702   jresult = (void *)result;
85703   return jresult;
85704 }
85705
85706
85707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85708   void * jresult ;
85709   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85710   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85711
85712   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85713   {
85714     try {
85715       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85716     } catch (std::out_of_range& e) {
85717       {
85718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85719       };
85720     } catch (std::exception& e) {
85721       {
85722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85723       };
85724     } catch (Dali::DaliException e) {
85725       {
85726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85727       };
85728     } catch (...) {
85729       {
85730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85731       };
85732     }
85733   }
85734
85735   jresult = (void *)result;
85736   return jresult;
85737 }
85738
85739
85740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85741   void * jresult ;
85742   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85743   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85744
85745   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85746   {
85747     try {
85748       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85749     } catch (std::out_of_range& e) {
85750       {
85751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85752       };
85753     } catch (std::exception& e) {
85754       {
85755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85756       };
85757     } catch (Dali::DaliException e) {
85758       {
85759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85760       };
85761     } catch (...) {
85762       {
85763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85764       };
85765     }
85766   }
85767
85768   jresult = (void *)result;
85769   return jresult;
85770 }
85771
85772
85773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85774   void * jresult ;
85775   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85776   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85777
85778   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85779   {
85780     try {
85781       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85782     } catch (std::out_of_range& e) {
85783       {
85784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85785       };
85786     } catch (std::exception& e) {
85787       {
85788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85789       };
85790     } catch (Dali::DaliException e) {
85791       {
85792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85793       };
85794     } catch (...) {
85795       {
85796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85797       };
85798     }
85799   }
85800
85801   jresult = (void *)result;
85802   return jresult;
85803 }
85804
85805
85806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85807   void * jresult ;
85808   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85809   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85810
85811   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85812   {
85813     try {
85814       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85815     } catch (std::out_of_range& e) {
85816       {
85817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85818       };
85819     } catch (std::exception& e) {
85820       {
85821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85822       };
85823     } catch (Dali::DaliException e) {
85824       {
85825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85826       };
85827     } catch (...) {
85828       {
85829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85830       };
85831     }
85832   }
85833
85834   jresult = (void *)result;
85835   return jresult;
85836 }
85837
85838
85839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85840   void * jresult ;
85841   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85842   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85843
85844   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85845   {
85846     try {
85847       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85848     } catch (std::out_of_range& e) {
85849       {
85850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85851       };
85852     } catch (std::exception& e) {
85853       {
85854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85855       };
85856     } catch (Dali::DaliException e) {
85857       {
85858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85859       };
85860     } catch (...) {
85861       {
85862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85863       };
85864     }
85865   }
85866
85867   jresult = (void *)result;
85868   return jresult;
85869 }
85870
85871
85872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85873   void * jresult ;
85874   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85875   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85876
85877   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85878   {
85879     try {
85880       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85881     } catch (std::out_of_range& e) {
85882       {
85883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85884       };
85885     } catch (std::exception& e) {
85886       {
85887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85888       };
85889     } catch (Dali::DaliException e) {
85890       {
85891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85892       };
85893     } catch (...) {
85894       {
85895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85896       };
85897     }
85898   }
85899
85900   jresult = (void *)result;
85901   return jresult;
85902 }
85903
85904
85905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85906   void * jresult ;
85907   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85908   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85909
85910   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85911   {
85912     try {
85913       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85914     } catch (std::out_of_range& e) {
85915       {
85916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85917       };
85918     } catch (std::exception& e) {
85919       {
85920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85921       };
85922     } catch (Dali::DaliException e) {
85923       {
85924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85925       };
85926     } catch (...) {
85927       {
85928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85929       };
85930     }
85931   }
85932
85933   jresult = (void *)result;
85934   return jresult;
85935 }
85936
85937
85938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85939   void * jresult ;
85940   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85941   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85942
85943   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85944   {
85945     try {
85946       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85947     } catch (std::out_of_range& e) {
85948       {
85949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85950       };
85951     } catch (std::exception& e) {
85952       {
85953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85954       };
85955     } catch (Dali::DaliException e) {
85956       {
85957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85958       };
85959     } catch (...) {
85960       {
85961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85962       };
85963     }
85964   }
85965
85966   jresult = (void *)result;
85967   return jresult;
85968 }
85969
85970
85971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85972   void * jresult ;
85973   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85974   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85975
85976   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85977   {
85978     try {
85979       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85980     } catch (std::out_of_range& e) {
85981       {
85982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85983       };
85984     } catch (std::exception& e) {
85985       {
85986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85987       };
85988     } catch (Dali::DaliException e) {
85989       {
85990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85991       };
85992     } catch (...) {
85993       {
85994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85995       };
85996     }
85997   }
85998
85999   jresult = (void *)result;
86000   return jresult;
86001 }
86002
86003
86004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86005   void * jresult ;
86006   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86007   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86008
86009   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86010   {
86011     try {
86012       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86013     } catch (std::out_of_range& e) {
86014       {
86015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86016       };
86017     } catch (std::exception& e) {
86018       {
86019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86020       };
86021     } catch (Dali::DaliException e) {
86022       {
86023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86024       };
86025     } catch (...) {
86026       {
86027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86028       };
86029     }
86030   }
86031
86032   jresult = (void *)result;
86033   return jresult;
86034 }
86035
86036
86037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86038   void * jresult ;
86039   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86040   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86041
86042   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86043   {
86044     try {
86045       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86046     } catch (std::out_of_range& e) {
86047       {
86048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86049       };
86050     } catch (std::exception& e) {
86051       {
86052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86053       };
86054     } catch (Dali::DaliException e) {
86055       {
86056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86057       };
86058     } catch (...) {
86059       {
86060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86061       };
86062     }
86063   }
86064
86065   jresult = (void *)result;
86066   return jresult;
86067 }
86068
86069
86070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86071   void * jresult ;
86072   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86073   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86074
86075   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86076   {
86077     try {
86078       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86079     } catch (std::out_of_range& e) {
86080       {
86081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86082       };
86083     } catch (std::exception& e) {
86084       {
86085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86086       };
86087     } catch (Dali::DaliException e) {
86088       {
86089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86090       };
86091     } catch (...) {
86092       {
86093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86094       };
86095     }
86096   }
86097
86098   jresult = (void *)result;
86099   return jresult;
86100 }
86101
86102
86103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86104   void * jresult ;
86105   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86106   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86107
86108   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86109   {
86110     try {
86111       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86112     } catch (std::out_of_range& e) {
86113       {
86114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86115       };
86116     } catch (std::exception& e) {
86117       {
86118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86119       };
86120     } catch (Dali::DaliException e) {
86121       {
86122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86123       };
86124     } catch (...) {
86125       {
86126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86127       };
86128     }
86129   }
86130
86131   jresult = (void *)result;
86132   return jresult;
86133 }
86134
86135
86136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86137   void * jresult ;
86138   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86139   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86140
86141   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86142   {
86143     try {
86144       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86145     } catch (std::out_of_range& e) {
86146       {
86147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86148       };
86149     } catch (std::exception& e) {
86150       {
86151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86152       };
86153     } catch (Dali::DaliException e) {
86154       {
86155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86156       };
86157     } catch (...) {
86158       {
86159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86160       };
86161     }
86162   }
86163
86164   jresult = (void *)result;
86165   return jresult;
86166 }
86167
86168
86169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86170   void * jresult ;
86171   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86172   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86173
86174   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86175   {
86176     try {
86177       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86178     } catch (std::out_of_range& e) {
86179       {
86180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86181       };
86182     } catch (std::exception& e) {
86183       {
86184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86185       };
86186     } catch (Dali::DaliException e) {
86187       {
86188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86189       };
86190     } catch (...) {
86191       {
86192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86193       };
86194     }
86195   }
86196
86197   jresult = (void *)result;
86198   return jresult;
86199 }
86200
86201
86202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86203   void * jresult ;
86204   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86205   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86206
86207   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86208   {
86209     try {
86210       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86211     } catch (std::out_of_range& e) {
86212       {
86213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86214       };
86215     } catch (std::exception& e) {
86216       {
86217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86218       };
86219     } catch (Dali::DaliException e) {
86220       {
86221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86222       };
86223     } catch (...) {
86224       {
86225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86226       };
86227     }
86228   }
86229
86230   jresult = (void *)result;
86231   return jresult;
86232 }
86233
86234
86235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86236   void * jresult ;
86237   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86238   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86239
86240   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86241   {
86242     try {
86243       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86244     } catch (std::out_of_range& e) {
86245       {
86246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86247       };
86248     } catch (std::exception& e) {
86249       {
86250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86251       };
86252     } catch (Dali::DaliException e) {
86253       {
86254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86255       };
86256     } catch (...) {
86257       {
86258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86259       };
86260     }
86261   }
86262
86263   jresult = (void *)result;
86264   return jresult;
86265 }
86266
86267
86268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86269   void * jresult ;
86270   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86271   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86272
86273   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86274   {
86275     try {
86276       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86277     } catch (std::out_of_range& e) {
86278       {
86279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86280       };
86281     } catch (std::exception& e) {
86282       {
86283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86284       };
86285     } catch (Dali::DaliException e) {
86286       {
86287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86288       };
86289     } catch (...) {
86290       {
86291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86292       };
86293     }
86294   }
86295
86296   jresult = (void *)result;
86297   return jresult;
86298 }
86299
86300
86301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86302   void * jresult ;
86303   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86304   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86305
86306   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86307   {
86308     try {
86309       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86310     } catch (std::out_of_range& e) {
86311       {
86312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86313       };
86314     } catch (std::exception& e) {
86315       {
86316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86317       };
86318     } catch (Dali::DaliException e) {
86319       {
86320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86321       };
86322     } catch (...) {
86323       {
86324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86325       };
86326     }
86327   }
86328
86329   jresult = (void *)result;
86330   return jresult;
86331 }
86332
86333
86334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86335   void * jresult ;
86336   Dali::Toolkit::StyleManager *result = 0 ;
86337
86338   {
86339     try {
86340       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86341     } catch (std::out_of_range& e) {
86342       {
86343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86344       };
86345     } catch (std::exception& e) {
86346       {
86347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86348       };
86349     } catch (Dali::DaliException e) {
86350       {
86351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86352       };
86353     } catch (...) {
86354       {
86355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86356       };
86357     }
86358   }
86359
86360   jresult = (void *)result;
86361   return jresult;
86362 }
86363
86364
86365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86366   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86367
86368   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86369   {
86370     try {
86371       delete arg1;
86372     } catch (std::out_of_range& e) {
86373       {
86374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86375       };
86376     } catch (std::exception& e) {
86377       {
86378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86379       };
86380     } catch (Dali::DaliException e) {
86381       {
86382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86383       };
86384     } catch (...) {
86385       {
86386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86387       };
86388     }
86389   }
86390
86391 }
86392
86393
86394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86395   void * jresult ;
86396   Dali::Toolkit::StyleManager result;
86397
86398   {
86399     try {
86400       result = Dali::Toolkit::StyleManager::Get();
86401     } catch (std::out_of_range& e) {
86402       {
86403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86404       };
86405     } catch (std::exception& e) {
86406       {
86407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86408       };
86409     } catch (Dali::DaliException e) {
86410       {
86411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86412       };
86413     } catch (...) {
86414       {
86415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86416       };
86417     }
86418   }
86419
86420   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86421   return jresult;
86422 }
86423
86424
86425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86426   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86427   std::string *arg2 = 0 ;
86428
86429   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86430   if (!jarg2) {
86431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86432     return ;
86433   }
86434   std::string arg2_str(jarg2);
86435   arg2 = &arg2_str;
86436   {
86437     try {
86438       (arg1)->ApplyTheme((std::string const &)*arg2);
86439     } catch (std::out_of_range& e) {
86440       {
86441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86442       };
86443     } catch (std::exception& e) {
86444       {
86445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86446       };
86447     } catch (Dali::DaliException e) {
86448       {
86449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86450       };
86451     } catch (...) {
86452       {
86453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86454       };
86455     }
86456   }
86457
86458
86459   //argout typemap for const std::string&
86460
86461 }
86462
86463
86464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86465   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86466
86467   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86468   {
86469     try {
86470       (arg1)->ApplyDefaultTheme();
86471     } catch (std::out_of_range& e) {
86472       {
86473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86474       };
86475     } catch (std::exception& e) {
86476       {
86477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86478       };
86479     } catch (Dali::DaliException e) {
86480       {
86481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86482       };
86483     } catch (...) {
86484       {
86485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86486       };
86487     }
86488   }
86489
86490 }
86491
86492
86493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86494   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86495   std::string *arg2 = 0 ;
86496   Dali::Property::Value *arg3 = 0 ;
86497
86498   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86499   if (!jarg2) {
86500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86501     return ;
86502   }
86503   std::string arg2_str(jarg2);
86504   arg2 = &arg2_str;
86505   arg3 = (Dali::Property::Value *)jarg3;
86506   if (!arg3) {
86507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86508     return ;
86509   }
86510   {
86511     try {
86512       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86513     } catch (std::out_of_range& e) {
86514       {
86515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86516       };
86517     } catch (std::exception& e) {
86518       {
86519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86520       };
86521     } catch (Dali::DaliException e) {
86522       {
86523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86524       };
86525     } catch (...) {
86526       {
86527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86528       };
86529     }
86530   }
86531
86532
86533   //argout typemap for const std::string&
86534
86535 }
86536
86537
86538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86539   unsigned int jresult ;
86540   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86541   std::string *arg2 = 0 ;
86542   Dali::Property::Value *arg3 = 0 ;
86543   bool result;
86544
86545   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86546   if (!jarg2) {
86547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86548     return 0;
86549   }
86550   std::string arg2_str(jarg2);
86551   arg2 = &arg2_str;
86552   arg3 = (Dali::Property::Value *)jarg3;
86553   if (!arg3) {
86554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86555     return 0;
86556   }
86557   {
86558     try {
86559       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86560     } catch (std::out_of_range& e) {
86561       {
86562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86563       };
86564     } catch (std::exception& e) {
86565       {
86566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86567       };
86568     } catch (Dali::DaliException e) {
86569       {
86570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86571       };
86572     } catch (...) {
86573       {
86574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86575       };
86576     }
86577   }
86578
86579   jresult = result;
86580
86581   //argout typemap for const std::string&
86582
86583   return jresult;
86584 }
86585
86586
86587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86588   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86589   Dali::Toolkit::Control arg2 ;
86590   std::string *arg3 = 0 ;
86591   std::string *arg4 = 0 ;
86592   Dali::Toolkit::Control *argp2 ;
86593
86594   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86595   argp2 = (Dali::Toolkit::Control *)jarg2;
86596   if (!argp2) {
86597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86598     return ;
86599   }
86600   arg2 = *argp2;
86601   if (!jarg3) {
86602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86603     return ;
86604   }
86605   std::string arg3_str(jarg3);
86606   arg3 = &arg3_str;
86607   if (!jarg4) {
86608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86609     return ;
86610   }
86611   std::string arg4_str(jarg4);
86612   arg4 = &arg4_str;
86613   {
86614     try {
86615       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86616     } catch (std::out_of_range& e) {
86617       {
86618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86619       };
86620     } catch (std::exception& e) {
86621       {
86622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86623       };
86624     } catch (Dali::DaliException e) {
86625       {
86626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86627       };
86628     } catch (...) {
86629       {
86630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86631       };
86632     }
86633   }
86634
86635
86636   //argout typemap for const std::string&
86637
86638
86639   //argout typemap for const std::string&
86640
86641 }
86642
86643
86644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86645   void * jresult ;
86646   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86647   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86648
86649   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86650   {
86651     try {
86652       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86653     } catch (std::out_of_range& e) {
86654       {
86655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86656       };
86657     } catch (std::exception& e) {
86658       {
86659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86660       };
86661     } catch (Dali::DaliException e) {
86662       {
86663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86664       };
86665     } catch (...) {
86666       {
86667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86668       };
86669     }
86670   }
86671
86672   jresult = (void *)result;
86673   return jresult;
86674 }
86675
86676
86677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86678   int jresult ;
86679   int result;
86680
86681   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86682   jresult = (int)result;
86683   return jresult;
86684 }
86685
86686
86687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86688   int jresult ;
86689   int result;
86690
86691   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86692   jresult = (int)result;
86693   return jresult;
86694 }
86695
86696
86697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86698   int jresult ;
86699   int result;
86700
86701   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86702   jresult = (int)result;
86703   return jresult;
86704 }
86705
86706
86707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86708   int jresult ;
86709   int result;
86710
86711   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86712   jresult = (int)result;
86713   return jresult;
86714 }
86715
86716
86717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86718   int jresult ;
86719   int result;
86720
86721   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86722   jresult = (int)result;
86723   return jresult;
86724 }
86725
86726
86727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86728   int jresult ;
86729   int result;
86730
86731   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86732   jresult = (int)result;
86733   return jresult;
86734 }
86735
86736
86737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86738   int jresult ;
86739   int result;
86740
86741   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86742   jresult = (int)result;
86743   return jresult;
86744 }
86745
86746
86747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86748   int jresult ;
86749   int result;
86750
86751   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86752   jresult = (int)result;
86753   return jresult;
86754 }
86755
86756
86757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86758   int jresult ;
86759   int result;
86760
86761   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86762   jresult = (int)result;
86763   return jresult;
86764 }
86765
86766
86767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86768   int jresult ;
86769   int result;
86770
86771   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86772   jresult = (int)result;
86773   return jresult;
86774 }
86775
86776
86777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86778   int jresult ;
86779   int result;
86780
86781   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86782   jresult = (int)result;
86783   return jresult;
86784 }
86785
86786
86787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86788   int jresult ;
86789   int result;
86790
86791   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86792   jresult = (int)result;
86793   return jresult;
86794 }
86795
86796
86797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86798   int jresult ;
86799   int result;
86800
86801   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86802   jresult = (int)result;
86803   return jresult;
86804 }
86805
86806
86807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86808   int jresult ;
86809   int result;
86810
86811   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86812   jresult = (int)result;
86813   return jresult;
86814 }
86815
86816
86817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86818   int jresult ;
86819   int result;
86820
86821   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86822   jresult = (int)result;
86823   return jresult;
86824 }
86825
86826
86827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86828   void * jresult ;
86829   Dali::Toolkit::Slider::Property *result = 0 ;
86830
86831   {
86832     try {
86833       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86834     } catch (std::out_of_range& e) {
86835       {
86836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86837       };
86838     } catch (std::exception& e) {
86839       {
86840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86841       };
86842     } catch (Dali::DaliException e) {
86843       {
86844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86845       };
86846     } catch (...) {
86847       {
86848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86849       };
86850     }
86851   }
86852
86853   jresult = (void *)result;
86854   return jresult;
86855 }
86856
86857
86858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86859   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86860
86861   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86862   {
86863     try {
86864       delete arg1;
86865     } catch (std::out_of_range& e) {
86866       {
86867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86868       };
86869     } catch (std::exception& e) {
86870       {
86871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86872       };
86873     } catch (Dali::DaliException e) {
86874       {
86875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86876       };
86877     } catch (...) {
86878       {
86879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86880       };
86881     }
86882   }
86883
86884 }
86885
86886
86887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86888   void * jresult ;
86889   Dali::Toolkit::Slider result;
86890
86891   {
86892     try {
86893       result = Dali::Toolkit::Slider::New();
86894     } catch (std::out_of_range& e) {
86895       {
86896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86897       };
86898     } catch (std::exception& e) {
86899       {
86900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86901       };
86902     } catch (Dali::DaliException e) {
86903       {
86904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86905       };
86906     } catch (...) {
86907       {
86908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86909       };
86910     }
86911   }
86912
86913   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86914   return jresult;
86915 }
86916
86917
86918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86919   void * jresult ;
86920   Dali::Toolkit::Slider *result = 0 ;
86921
86922   {
86923     try {
86924       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86925     } catch (std::out_of_range& e) {
86926       {
86927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86928       };
86929     } catch (std::exception& e) {
86930       {
86931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86932       };
86933     } catch (Dali::DaliException e) {
86934       {
86935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86936       };
86937     } catch (...) {
86938       {
86939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86940       };
86941     }
86942   }
86943
86944   jresult = (void *)result;
86945   return jresult;
86946 }
86947
86948
86949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86950   void * jresult ;
86951   Dali::Toolkit::Slider *arg1 = 0 ;
86952   Dali::Toolkit::Slider *result = 0 ;
86953
86954   arg1 = (Dali::Toolkit::Slider *)jarg1;
86955   if (!arg1) {
86956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86957     return 0;
86958   }
86959   {
86960     try {
86961       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86962     } catch (std::out_of_range& e) {
86963       {
86964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86965       };
86966     } catch (std::exception& e) {
86967       {
86968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86969       };
86970     } catch (Dali::DaliException e) {
86971       {
86972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86973       };
86974     } catch (...) {
86975       {
86976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86977       };
86978     }
86979   }
86980
86981   jresult = (void *)result;
86982   return jresult;
86983 }
86984
86985
86986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86987   void * jresult ;
86988   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86989   Dali::Toolkit::Slider *arg2 = 0 ;
86990   Dali::Toolkit::Slider *result = 0 ;
86991
86992   arg1 = (Dali::Toolkit::Slider *)jarg1;
86993   arg2 = (Dali::Toolkit::Slider *)jarg2;
86994   if (!arg2) {
86995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86996     return 0;
86997   }
86998   {
86999     try {
87000       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87001     } catch (std::out_of_range& e) {
87002       {
87003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87004       };
87005     } catch (std::exception& e) {
87006       {
87007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87008       };
87009     } catch (Dali::DaliException e) {
87010       {
87011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87012       };
87013     } catch (...) {
87014       {
87015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87016       };
87017     }
87018   }
87019
87020   jresult = (void *)result;
87021   return jresult;
87022 }
87023
87024
87025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87026   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87027
87028   arg1 = (Dali::Toolkit::Slider *)jarg1;
87029   {
87030     try {
87031       delete arg1;
87032     } catch (std::out_of_range& e) {
87033       {
87034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87035       };
87036     } catch (std::exception& e) {
87037       {
87038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87039       };
87040     } catch (Dali::DaliException e) {
87041       {
87042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87043       };
87044     } catch (...) {
87045       {
87046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87047       };
87048     }
87049   }
87050
87051 }
87052
87053
87054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87055   void * jresult ;
87056   Dali::BaseHandle arg1 ;
87057   Dali::BaseHandle *argp1 ;
87058   Dali::Toolkit::Slider result;
87059
87060   argp1 = (Dali::BaseHandle *)jarg1;
87061   if (!argp1) {
87062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87063     return 0;
87064   }
87065   arg1 = *argp1;
87066   {
87067     try {
87068       result = Dali::Toolkit::Slider::DownCast(arg1);
87069     } catch (std::out_of_range& e) {
87070       {
87071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87072       };
87073     } catch (std::exception& e) {
87074       {
87075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87076       };
87077     } catch (Dali::DaliException e) {
87078       {
87079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87080       };
87081     } catch (...) {
87082       {
87083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87084       };
87085     }
87086   }
87087
87088   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87089   return jresult;
87090 }
87091
87092
87093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87094   void * jresult ;
87095   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87096   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87097
87098   arg1 = (Dali::Toolkit::Slider *)jarg1;
87099   {
87100     try {
87101       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87102     } catch (std::out_of_range& e) {
87103       {
87104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87105       };
87106     } catch (std::exception& e) {
87107       {
87108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87109       };
87110     } catch (Dali::DaliException e) {
87111       {
87112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87113       };
87114     } catch (...) {
87115       {
87116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87117       };
87118     }
87119   }
87120
87121   jresult = (void *)result;
87122   return jresult;
87123 }
87124
87125
87126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87127   void * jresult ;
87128   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87129   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87130
87131   arg1 = (Dali::Toolkit::Slider *)jarg1;
87132   {
87133     try {
87134       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87135     } catch (std::out_of_range& e) {
87136       {
87137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87138       };
87139     } catch (std::exception& e) {
87140       {
87141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87142       };
87143     } catch (Dali::DaliException e) {
87144       {
87145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87146       };
87147     } catch (...) {
87148       {
87149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87150       };
87151     }
87152   }
87153
87154   jresult = (void *)result;
87155   return jresult;
87156 }
87157
87158
87159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87160   void * jresult ;
87161   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87162   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87163
87164   arg1 = (Dali::Toolkit::Slider *)jarg1;
87165   {
87166     try {
87167       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87168     } catch (std::out_of_range& e) {
87169       {
87170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87171       };
87172     } catch (std::exception& e) {
87173       {
87174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87175       };
87176     } catch (Dali::DaliException e) {
87177       {
87178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87179       };
87180     } catch (...) {
87181       {
87182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87183       };
87184     }
87185   }
87186
87187   jresult = (void *)result;
87188   return jresult;
87189 }
87190
87191
87192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87193   int jresult ;
87194   int result;
87195
87196   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87197   jresult = (int)result;
87198   return jresult;
87199 }
87200
87201
87202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87203   int jresult ;
87204   int result;
87205
87206   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87207   jresult = (int)result;
87208   return jresult;
87209 }
87210
87211
87212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87213   int jresult ;
87214   int result;
87215
87216   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87217   jresult = (int)result;
87218   return jresult;
87219 }
87220
87221
87222 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87223   int jresult ;
87224   int result;
87225
87226   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87227   jresult = (int)result;
87228   return jresult;
87229 }
87230
87231
87232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87233   int result;
87234
87235   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87236
87237   return result;
87238 }
87239
87240
87241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87242   void * jresult ;
87243   Dali::Toolkit::VideoView::Property *result = 0 ;
87244
87245   {
87246     try {
87247       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87248     } catch (std::out_of_range& e) {
87249       {
87250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87251       };
87252     } catch (std::exception& e) {
87253       {
87254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87255       };
87256     } catch (Dali::DaliException e) {
87257       {
87258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87259       };
87260     } catch (...) {
87261       {
87262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87263       };
87264     }
87265   }
87266
87267   jresult = (void *)result;
87268   return jresult;
87269 }
87270
87271
87272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87273   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87274
87275   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87276   {
87277     try {
87278       delete arg1;
87279     } catch (std::out_of_range& e) {
87280       {
87281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87282       };
87283     } catch (std::exception& e) {
87284       {
87285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87286       };
87287     } catch (Dali::DaliException e) {
87288       {
87289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87290       };
87291     } catch (...) {
87292       {
87293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87294       };
87295     }
87296   }
87297
87298 }
87299
87300
87301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87302   void * jresult ;
87303   Dali::Toolkit::VideoView result;
87304
87305   {
87306     try {
87307       result = Dali::Toolkit::VideoView::New();
87308     } catch (std::out_of_range& e) {
87309       {
87310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87311       };
87312     } catch (std::exception& e) {
87313       {
87314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87315       };
87316     } catch (Dali::DaliException e) {
87317       {
87318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87319       };
87320     } catch (...) {
87321       {
87322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87323       };
87324     }
87325   }
87326
87327   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87328   return jresult;
87329 }
87330
87331
87332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87333   void * jresult ;
87334   std::string *arg1 = 0 ;
87335   Dali::Toolkit::VideoView result;
87336
87337   if (!jarg1) {
87338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87339     return 0;
87340   }
87341   std::string arg1_str(jarg1);
87342   arg1 = &arg1_str;
87343   {
87344     try {
87345       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87346     } catch (std::out_of_range& e) {
87347       {
87348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87349       };
87350     } catch (std::exception& e) {
87351       {
87352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87353       };
87354     } catch (Dali::DaliException e) {
87355       {
87356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87357       };
87358     } catch (...) {
87359       {
87360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87361       };
87362     }
87363   }
87364
87365   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87366
87367   //argout typemap for const std::string&
87368
87369   return jresult;
87370 }
87371
87372
87373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87374   void * jresult ;
87375   Dali::Toolkit::VideoView *result = 0 ;
87376
87377   {
87378     try {
87379       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87380     } catch (std::out_of_range& e) {
87381       {
87382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87383       };
87384     } catch (std::exception& e) {
87385       {
87386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87387       };
87388     } catch (Dali::DaliException e) {
87389       {
87390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87391       };
87392     } catch (...) {
87393       {
87394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87395       };
87396     }
87397   }
87398
87399   jresult = (void *)result;
87400   return jresult;
87401 }
87402
87403
87404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87405   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87406
87407   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87408   {
87409     try {
87410       delete arg1;
87411     } catch (std::out_of_range& e) {
87412       {
87413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87414       };
87415     } catch (std::exception& e) {
87416       {
87417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87418       };
87419     } catch (Dali::DaliException e) {
87420       {
87421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87422       };
87423     } catch (...) {
87424       {
87425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87426       };
87427     }
87428   }
87429
87430 }
87431
87432
87433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87434   void * jresult ;
87435   Dali::Toolkit::VideoView *arg1 = 0 ;
87436   Dali::Toolkit::VideoView *result = 0 ;
87437
87438   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87439   if (!arg1) {
87440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87441     return 0;
87442   }
87443   {
87444     try {
87445       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87446     } catch (std::out_of_range& e) {
87447       {
87448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87449       };
87450     } catch (std::exception& e) {
87451       {
87452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87453       };
87454     } catch (Dali::DaliException e) {
87455       {
87456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87457       };
87458     } catch (...) {
87459       {
87460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87461       };
87462     }
87463   }
87464
87465   jresult = (void *)result;
87466   return jresult;
87467 }
87468
87469
87470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87471   void * jresult ;
87472   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87473   Dali::Toolkit::VideoView *arg2 = 0 ;
87474   Dali::Toolkit::VideoView *result = 0 ;
87475
87476   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87477   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87478   if (!arg2) {
87479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87480     return 0;
87481   }
87482   {
87483     try {
87484       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87485     } catch (std::out_of_range& e) {
87486       {
87487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87488       };
87489     } catch (std::exception& e) {
87490       {
87491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87492       };
87493     } catch (Dali::DaliException e) {
87494       {
87495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87496       };
87497     } catch (...) {
87498       {
87499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87500       };
87501     }
87502   }
87503
87504   jresult = (void *)result;
87505   return jresult;
87506 }
87507
87508
87509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87510   void * jresult ;
87511   Dali::BaseHandle arg1 ;
87512   Dali::BaseHandle *argp1 ;
87513   Dali::Toolkit::VideoView result;
87514
87515   argp1 = (Dali::BaseHandle *)jarg1;
87516   if (!argp1) {
87517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87518     return 0;
87519   }
87520   arg1 = *argp1;
87521   {
87522     try {
87523       result = Dali::Toolkit::VideoView::DownCast(arg1);
87524     } catch (std::out_of_range& e) {
87525       {
87526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87527       };
87528     } catch (std::exception& e) {
87529       {
87530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87531       };
87532     } catch (Dali::DaliException e) {
87533       {
87534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87535       };
87536     } catch (...) {
87537       {
87538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87539       };
87540     }
87541   }
87542
87543   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87544   return jresult;
87545 }
87546
87547
87548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87549   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87550
87551   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87552   {
87553     try {
87554       (arg1)->Play();
87555     } catch (std::out_of_range& e) {
87556       {
87557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87558       };
87559     } catch (std::exception& e) {
87560       {
87561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87562       };
87563     } catch (Dali::DaliException e) {
87564       {
87565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87566       };
87567     } catch (...) {
87568       {
87569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87570       };
87571     }
87572   }
87573
87574 }
87575
87576
87577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87578   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87579
87580   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87581   {
87582     try {
87583       (arg1)->Pause();
87584     } catch (std::out_of_range& e) {
87585       {
87586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87587       };
87588     } catch (std::exception& e) {
87589       {
87590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87591       };
87592     } catch (Dali::DaliException e) {
87593       {
87594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87595       };
87596     } catch (...) {
87597       {
87598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87599       };
87600     }
87601   }
87602
87603 }
87604
87605
87606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87607   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87608
87609   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87610   {
87611     try {
87612       (arg1)->Stop();
87613     } catch (std::out_of_range& e) {
87614       {
87615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87616       };
87617     } catch (std::exception& e) {
87618       {
87619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87620       };
87621     } catch (Dali::DaliException e) {
87622       {
87623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87624       };
87625     } catch (...) {
87626       {
87627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87628       };
87629     }
87630   }
87631
87632 }
87633
87634
87635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87636   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87637   int arg2 ;
87638
87639   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87640   arg2 = (int)jarg2;
87641   {
87642     try {
87643       (arg1)->Forward(arg2);
87644     } catch (std::out_of_range& e) {
87645       {
87646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87647       };
87648     } catch (std::exception& e) {
87649       {
87650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87651       };
87652     } catch (Dali::DaliException e) {
87653       {
87654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87655       };
87656     } catch (...) {
87657       {
87658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87659       };
87660     }
87661   }
87662
87663 }
87664
87665
87666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87667   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87668   int arg2 ;
87669
87670   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87671   arg2 = (int)jarg2;
87672   {
87673     try {
87674       (arg1)->Backward(arg2);
87675     } catch (std::out_of_range& e) {
87676       {
87677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87678       };
87679     } catch (std::exception& e) {
87680       {
87681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87682       };
87683     } catch (Dali::DaliException e) {
87684       {
87685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87686       };
87687     } catch (...) {
87688       {
87689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87690       };
87691     }
87692   }
87693
87694 }
87695
87696
87697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87698   void * jresult ;
87699   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87700   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87701
87702   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87703   {
87704     try {
87705       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87706     } catch (std::out_of_range& e) {
87707       {
87708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87709       };
87710     } catch (std::exception& e) {
87711       {
87712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87713       };
87714     } catch (Dali::DaliException e) {
87715       {
87716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87717       };
87718     } catch (...) {
87719       {
87720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87721       };
87722     }
87723   }
87724
87725   jresult = (void *)result;
87726   return jresult;
87727 }
87728
87729
87730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87731   int jresult ;
87732   int result;
87733
87734   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87735   jresult = (int)result;
87736   return jresult;
87737 }
87738
87739
87740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87741   int jresult ;
87742   int result;
87743
87744   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87745   jresult = (int)result;
87746   return jresult;
87747 }
87748
87749
87750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87751   int jresult ;
87752   int result;
87753
87754   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87755   jresult = (int)result;
87756   return jresult;
87757 }
87758
87759
87760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87761   int jresult ;
87762   int result;
87763
87764   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87765   jresult = (int)result;
87766   return jresult;
87767 }
87768
87769
87770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87771   int jresult ;
87772   int result;
87773
87774   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87775   jresult = (int)result;
87776   return jresult;
87777 }
87778
87779
87780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87781   int jresult ;
87782   int result;
87783
87784   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87785   jresult = (int)result;
87786   return jresult;
87787 }
87788
87789
87790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87791   int jresult ;
87792   int result;
87793
87794   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87795   jresult = (int)result;
87796   return jresult;
87797 }
87798
87799
87800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87801   int jresult ;
87802   int result;
87803
87804   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87805   jresult = (int)result;
87806   return jresult;
87807 }
87808
87809
87810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87811   int jresult ;
87812   int result;
87813
87814   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87815   jresult = (int)result;
87816   return jresult;
87817 }
87818
87819
87820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87821   int jresult ;
87822   int result;
87823
87824   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87825   jresult = (int)result;
87826   return jresult;
87827 }
87828
87829
87830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87831   int jresult ;
87832   int result;
87833
87834   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87835   jresult = (int)result;
87836   return jresult;
87837 }
87838
87839
87840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87841   int jresult ;
87842   int result;
87843
87844   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87845   jresult = (int)result;
87846   return jresult;
87847 }
87848
87849
87850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87851   int jresult ;
87852   int result;
87853
87854   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87855   jresult = (int)result;
87856   return jresult;
87857 }
87858
87859
87860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87861   int jresult ;
87862   int result;
87863
87864   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87865   jresult = (int)result;
87866   return jresult;
87867 }
87868
87869
87870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87871   int jresult ;
87872   int result;
87873
87874   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87875   jresult = (int)result;
87876   return jresult;
87877 }
87878
87879
87880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87881   int jresult ;
87882   int result;
87883
87884   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87885   jresult = (int)result;
87886   return jresult;
87887 }
87888
87889
87890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87891   int jresult ;
87892   int result;
87893
87894   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87895   jresult = (int)result;
87896   return jresult;
87897 }
87898
87899
87900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87901   int jresult ;
87902   int result;
87903
87904   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87905   jresult = (int)result;
87906   return jresult;
87907 }
87908
87909
87910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87911   int jresult ;
87912   int result;
87913
87914   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87915   jresult = (int)result;
87916   return jresult;
87917 }
87918
87919
87920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87921   int jresult ;
87922   int result;
87923
87924   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87925   jresult = (int)result;
87926   return jresult;
87927 }
87928
87929
87930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87931   int jresult ;
87932   int result;
87933
87934   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87935   jresult = (int)result;
87936   return jresult;
87937 }
87938
87939
87940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87941   void * jresult ;
87942   Dali::Toolkit::Popup::Property *result = 0 ;
87943
87944   {
87945     try {
87946       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87947     } catch (std::out_of_range& e) {
87948       {
87949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87950       };
87951     } catch (std::exception& e) {
87952       {
87953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87954       };
87955     } catch (Dali::DaliException e) {
87956       {
87957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87958       };
87959     } catch (...) {
87960       {
87961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87962       };
87963     }
87964   }
87965
87966   jresult = (void *)result;
87967   return jresult;
87968 }
87969
87970
87971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87972   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87973
87974   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87975   {
87976     try {
87977       delete arg1;
87978     } catch (std::out_of_range& e) {
87979       {
87980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87981       };
87982     } catch (std::exception& e) {
87983       {
87984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87985       };
87986     } catch (Dali::DaliException e) {
87987       {
87988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87989       };
87990     } catch (...) {
87991       {
87992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87993       };
87994     }
87995   }
87996
87997 }
87998
87999
88000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88001   void * jresult ;
88002   Dali::Toolkit::Popup *result = 0 ;
88003
88004   {
88005     try {
88006       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88007     } catch (std::out_of_range& e) {
88008       {
88009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88010       };
88011     } catch (std::exception& e) {
88012       {
88013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88014       };
88015     } catch (Dali::DaliException e) {
88016       {
88017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88018       };
88019     } catch (...) {
88020       {
88021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88022       };
88023     }
88024   }
88025
88026   jresult = (void *)result;
88027   return jresult;
88028 }
88029
88030
88031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88032   void * jresult ;
88033   Dali::Toolkit::Popup result;
88034
88035   {
88036     try {
88037       result = Dali::Toolkit::Popup::New();
88038     } catch (std::out_of_range& e) {
88039       {
88040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88041       };
88042     } catch (std::exception& e) {
88043       {
88044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88045       };
88046     } catch (Dali::DaliException e) {
88047       {
88048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88049       };
88050     } catch (...) {
88051       {
88052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88053       };
88054     }
88055   }
88056
88057   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88058   return jresult;
88059 }
88060
88061
88062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88063   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88064
88065   arg1 = (Dali::Toolkit::Popup *)jarg1;
88066   {
88067     try {
88068       delete arg1;
88069     } catch (std::out_of_range& e) {
88070       {
88071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88072       };
88073     } catch (std::exception& e) {
88074       {
88075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88076       };
88077     } catch (Dali::DaliException e) {
88078       {
88079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88080       };
88081     } catch (...) {
88082       {
88083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88084       };
88085     }
88086   }
88087
88088 }
88089
88090
88091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88092   void * jresult ;
88093   Dali::Toolkit::Popup *arg1 = 0 ;
88094   Dali::Toolkit::Popup *result = 0 ;
88095
88096   arg1 = (Dali::Toolkit::Popup *)jarg1;
88097   if (!arg1) {
88098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88099     return 0;
88100   }
88101   {
88102     try {
88103       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88104     } catch (std::out_of_range& e) {
88105       {
88106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88107       };
88108     } catch (std::exception& e) {
88109       {
88110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88111       };
88112     } catch (Dali::DaliException e) {
88113       {
88114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88115       };
88116     } catch (...) {
88117       {
88118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88119       };
88120     }
88121   }
88122
88123   jresult = (void *)result;
88124   return jresult;
88125 }
88126
88127
88128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88129   void * jresult ;
88130   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88131   Dali::Toolkit::Popup *arg2 = 0 ;
88132   Dali::Toolkit::Popup *result = 0 ;
88133
88134   arg1 = (Dali::Toolkit::Popup *)jarg1;
88135   arg2 = (Dali::Toolkit::Popup *)jarg2;
88136   if (!arg2) {
88137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88138     return 0;
88139   }
88140   {
88141     try {
88142       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88143     } catch (std::out_of_range& e) {
88144       {
88145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88146       };
88147     } catch (std::exception& e) {
88148       {
88149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88150       };
88151     } catch (Dali::DaliException e) {
88152       {
88153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88154       };
88155     } catch (...) {
88156       {
88157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88158       };
88159     }
88160   }
88161
88162   jresult = (void *)result;
88163   return jresult;
88164 }
88165
88166
88167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88168   void * jresult ;
88169   Dali::BaseHandle arg1 ;
88170   Dali::BaseHandle *argp1 ;
88171   Dali::Toolkit::Popup result;
88172
88173   argp1 = (Dali::BaseHandle *)jarg1;
88174   if (!argp1) {
88175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88176     return 0;
88177   }
88178   arg1 = *argp1;
88179   {
88180     try {
88181       result = Dali::Toolkit::Popup::DownCast(arg1);
88182     } catch (std::out_of_range& e) {
88183       {
88184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88185       };
88186     } catch (std::exception& e) {
88187       {
88188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88189       };
88190     } catch (Dali::DaliException e) {
88191       {
88192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88193       };
88194     } catch (...) {
88195       {
88196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88197       };
88198     }
88199   }
88200
88201   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88202   return jresult;
88203 }
88204
88205
88206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88207   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88208   Dali::Actor arg2 ;
88209   Dali::Actor *argp2 ;
88210
88211   arg1 = (Dali::Toolkit::Popup *)jarg1;
88212   argp2 = (Dali::Actor *)jarg2;
88213   if (!argp2) {
88214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88215     return ;
88216   }
88217   arg2 = *argp2;
88218   {
88219     try {
88220       (arg1)->SetTitle(arg2);
88221     } catch (std::out_of_range& e) {
88222       {
88223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88224       };
88225     } catch (std::exception& e) {
88226       {
88227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88228       };
88229     } catch (Dali::DaliException e) {
88230       {
88231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88232       };
88233     } catch (...) {
88234       {
88235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88236       };
88237     }
88238   }
88239
88240 }
88241
88242
88243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88244   void * jresult ;
88245   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88246   Dali::Actor result;
88247
88248   arg1 = (Dali::Toolkit::Popup *)jarg1;
88249   {
88250     try {
88251       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88252     } catch (std::out_of_range& e) {
88253       {
88254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88255       };
88256     } catch (std::exception& e) {
88257       {
88258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88259       };
88260     } catch (Dali::DaliException e) {
88261       {
88262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88263       };
88264     } catch (...) {
88265       {
88266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88267       };
88268     }
88269   }
88270
88271   jresult = new Dali::Actor((const Dali::Actor &)result);
88272   return jresult;
88273 }
88274
88275
88276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88277   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88278   Dali::Actor arg2 ;
88279   Dali::Actor *argp2 ;
88280
88281   arg1 = (Dali::Toolkit::Popup *)jarg1;
88282   argp2 = (Dali::Actor *)jarg2;
88283   if (!argp2) {
88284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88285     return ;
88286   }
88287   arg2 = *argp2;
88288   {
88289     try {
88290       (arg1)->SetContent(arg2);
88291     } catch (std::out_of_range& e) {
88292       {
88293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88294       };
88295     } catch (std::exception& e) {
88296       {
88297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88298       };
88299     } catch (Dali::DaliException e) {
88300       {
88301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88302       };
88303     } catch (...) {
88304       {
88305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88306       };
88307     }
88308   }
88309
88310 }
88311
88312
88313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88314   void * jresult ;
88315   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88316   Dali::Actor result;
88317
88318   arg1 = (Dali::Toolkit::Popup *)jarg1;
88319   {
88320     try {
88321       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88322     } catch (std::out_of_range& e) {
88323       {
88324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88325       };
88326     } catch (std::exception& e) {
88327       {
88328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88329       };
88330     } catch (Dali::DaliException e) {
88331       {
88332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88333       };
88334     } catch (...) {
88335       {
88336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88337       };
88338     }
88339   }
88340
88341   jresult = new Dali::Actor((const Dali::Actor &)result);
88342   return jresult;
88343 }
88344
88345
88346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88347   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88348   Dali::Actor arg2 ;
88349   Dali::Actor *argp2 ;
88350
88351   arg1 = (Dali::Toolkit::Popup *)jarg1;
88352   argp2 = (Dali::Actor *)jarg2;
88353   if (!argp2) {
88354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88355     return ;
88356   }
88357   arg2 = *argp2;
88358   {
88359     try {
88360       (arg1)->SetFooter(arg2);
88361     } catch (std::out_of_range& e) {
88362       {
88363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88364       };
88365     } catch (std::exception& e) {
88366       {
88367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88368       };
88369     } catch (Dali::DaliException e) {
88370       {
88371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88372       };
88373     } catch (...) {
88374       {
88375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88376       };
88377     }
88378   }
88379
88380 }
88381
88382
88383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88384   void * jresult ;
88385   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88386   Dali::Actor result;
88387
88388   arg1 = (Dali::Toolkit::Popup *)jarg1;
88389   {
88390     try {
88391       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88392     } catch (std::out_of_range& e) {
88393       {
88394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88395       };
88396     } catch (std::exception& e) {
88397       {
88398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88399       };
88400     } catch (Dali::DaliException e) {
88401       {
88402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88403       };
88404     } catch (...) {
88405       {
88406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88407       };
88408     }
88409   }
88410
88411   jresult = new Dali::Actor((const Dali::Actor &)result);
88412   return jresult;
88413 }
88414
88415
88416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88417   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88418   Dali::Toolkit::Popup::DisplayState arg2 ;
88419
88420   arg1 = (Dali::Toolkit::Popup *)jarg1;
88421   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88422   {
88423     try {
88424       (arg1)->SetDisplayState(arg2);
88425     } catch (std::out_of_range& e) {
88426       {
88427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88428       };
88429     } catch (std::exception& e) {
88430       {
88431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88432       };
88433     } catch (Dali::DaliException e) {
88434       {
88435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88436       };
88437     } catch (...) {
88438       {
88439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88440       };
88441     }
88442   }
88443
88444 }
88445
88446
88447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88448   int jresult ;
88449   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88450   Dali::Toolkit::Popup::DisplayState result;
88451
88452   arg1 = (Dali::Toolkit::Popup *)jarg1;
88453   {
88454     try {
88455       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88456     } catch (std::out_of_range& e) {
88457       {
88458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88459       };
88460     } catch (std::exception& e) {
88461       {
88462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88463       };
88464     } catch (Dali::DaliException e) {
88465       {
88466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88467       };
88468     } catch (...) {
88469       {
88470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88471       };
88472     }
88473   }
88474
88475   jresult = (int)result;
88476   return jresult;
88477 }
88478
88479
88480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88481   void * jresult ;
88482   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88483   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88484
88485   arg1 = (Dali::Toolkit::Popup *)jarg1;
88486   {
88487     try {
88488       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88489     } catch (std::out_of_range& e) {
88490       {
88491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88492       };
88493     } catch (std::exception& e) {
88494       {
88495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88496       };
88497     } catch (Dali::DaliException e) {
88498       {
88499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88500       };
88501     } catch (...) {
88502       {
88503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88504       };
88505     }
88506   }
88507
88508   jresult = (void *)result;
88509   return jresult;
88510 }
88511
88512
88513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88514   void * jresult ;
88515   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88516   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88517
88518   arg1 = (Dali::Toolkit::Popup *)jarg1;
88519   {
88520     try {
88521       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88522     } catch (std::out_of_range& e) {
88523       {
88524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88525       };
88526     } catch (std::exception& e) {
88527       {
88528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88529       };
88530     } catch (Dali::DaliException e) {
88531       {
88532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88533       };
88534     } catch (...) {
88535       {
88536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88537       };
88538     }
88539   }
88540
88541   jresult = (void *)result;
88542   return jresult;
88543 }
88544
88545
88546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88547   void * jresult ;
88548   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88549   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88550
88551   arg1 = (Dali::Toolkit::Popup *)jarg1;
88552   {
88553     try {
88554       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88555     } catch (std::out_of_range& e) {
88556       {
88557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88558       };
88559     } catch (std::exception& e) {
88560       {
88561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88562       };
88563     } catch (Dali::DaliException e) {
88564       {
88565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88566       };
88567     } catch (...) {
88568       {
88569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88570       };
88571     }
88572   }
88573
88574   jresult = (void *)result;
88575   return jresult;
88576 }
88577
88578
88579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88580   void * jresult ;
88581   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88582   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88583
88584   arg1 = (Dali::Toolkit::Popup *)jarg1;
88585   {
88586     try {
88587       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88588     } catch (std::out_of_range& e) {
88589       {
88590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88591       };
88592     } catch (std::exception& e) {
88593       {
88594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88595       };
88596     } catch (Dali::DaliException e) {
88597       {
88598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88599       };
88600     } catch (...) {
88601       {
88602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88603       };
88604     }
88605   }
88606
88607   jresult = (void *)result;
88608   return jresult;
88609 }
88610
88611
88612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88613   void * jresult ;
88614   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88615   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88616
88617   arg1 = (Dali::Toolkit::Popup *)jarg1;
88618   {
88619     try {
88620       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88621     } catch (std::out_of_range& e) {
88622       {
88623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88624       };
88625     } catch (std::exception& e) {
88626       {
88627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88628       };
88629     } catch (Dali::DaliException e) {
88630       {
88631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88632       };
88633     } catch (...) {
88634       {
88635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88636       };
88637     }
88638   }
88639
88640   jresult = (void *)result;
88641   return jresult;
88642 }
88643
88644
88645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88646   int jresult ;
88647   int result;
88648
88649   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88650   jresult = (int)result;
88651   return jresult;
88652 }
88653
88654
88655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88656   int jresult ;
88657   int result;
88658
88659   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88660   jresult = (int)result;
88661   return jresult;
88662 }
88663
88664
88665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88666   int jresult ;
88667   int result;
88668
88669   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88670   jresult = (int)result;
88671   return jresult;
88672 }
88673
88674
88675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88676   int jresult ;
88677   int result;
88678
88679   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88680   jresult = (int)result;
88681   return jresult;
88682 }
88683
88684
88685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88686   int jresult ;
88687   int result;
88688
88689   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88690   jresult = (int)result;
88691   return jresult;
88692 }
88693
88694
88695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88696   int jresult ;
88697   int result;
88698
88699   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88700   jresult = (int)result;
88701   return jresult;
88702 }
88703
88704
88705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88706   int jresult ;
88707   int result;
88708
88709   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88710   jresult = (int)result;
88711   return jresult;
88712 }
88713
88714
88715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88716   int jresult ;
88717   int result;
88718
88719   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88720   jresult = (int)result;
88721   return jresult;
88722 }
88723
88724
88725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88726   int jresult ;
88727   int result;
88728
88729   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88730   jresult = (int)result;
88731   return jresult;
88732 }
88733
88734
88735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88736   void * jresult ;
88737   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88738
88739   {
88740     try {
88741       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88742     } catch (std::out_of_range& e) {
88743       {
88744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88745       };
88746     } catch (std::exception& e) {
88747       {
88748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88749       };
88750     } catch (Dali::DaliException e) {
88751       {
88752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88753       };
88754     } catch (...) {
88755       {
88756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88757       };
88758     }
88759   }
88760
88761   jresult = (void *)result;
88762   return jresult;
88763 }
88764
88765
88766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88767   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88768
88769   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88770   {
88771     try {
88772       delete arg1;
88773     } catch (std::out_of_range& e) {
88774       {
88775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88776       };
88777     } catch (std::exception& e) {
88778       {
88779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88780       };
88781     } catch (Dali::DaliException e) {
88782       {
88783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88784       };
88785     } catch (...) {
88786       {
88787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88788       };
88789     }
88790   }
88791
88792 }
88793
88794
88795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88796   void * jresult ;
88797   Dali::Toolkit::ProgressBar result;
88798
88799   {
88800     try {
88801       result = Dali::Toolkit::ProgressBar::New();
88802     } catch (std::out_of_range& e) {
88803       {
88804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88805       };
88806     } catch (std::exception& e) {
88807       {
88808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88809       };
88810     } catch (Dali::DaliException e) {
88811       {
88812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88813       };
88814     } catch (...) {
88815       {
88816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88817       };
88818     }
88819   }
88820
88821   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88822   return jresult;
88823 }
88824
88825
88826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88827   void * jresult ;
88828   Dali::Toolkit::ProgressBar *result = 0 ;
88829
88830   {
88831     try {
88832       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88833     } catch (std::out_of_range& e) {
88834       {
88835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88836       };
88837     } catch (std::exception& e) {
88838       {
88839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88840       };
88841     } catch (Dali::DaliException e) {
88842       {
88843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88844       };
88845     } catch (...) {
88846       {
88847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88848       };
88849     }
88850   }
88851
88852   jresult = (void *)result;
88853   return jresult;
88854 }
88855
88856
88857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88858   void * jresult ;
88859   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88860   Dali::Toolkit::ProgressBar *result = 0 ;
88861
88862   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88863   if (!arg1) {
88864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88865     return 0;
88866   }
88867   {
88868     try {
88869       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88870     } catch (std::out_of_range& e) {
88871       {
88872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88873       };
88874     } catch (std::exception& e) {
88875       {
88876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88877       };
88878     } catch (Dali::DaliException e) {
88879       {
88880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88881       };
88882     } catch (...) {
88883       {
88884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88885       };
88886     }
88887   }
88888
88889   jresult = (void *)result;
88890   return jresult;
88891 }
88892
88893
88894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88895   void * jresult ;
88896   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88897   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88898   Dali::Toolkit::ProgressBar *result = 0 ;
88899
88900   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88901   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88902   if (!arg2) {
88903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88904     return 0;
88905   }
88906   {
88907     try {
88908       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88909     } catch (std::out_of_range& e) {
88910       {
88911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88912       };
88913     } catch (std::exception& e) {
88914       {
88915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88916       };
88917     } catch (Dali::DaliException e) {
88918       {
88919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88920       };
88921     } catch (...) {
88922       {
88923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88924       };
88925     }
88926   }
88927
88928   jresult = (void *)result;
88929   return jresult;
88930 }
88931
88932
88933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88934   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88935
88936   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88937   {
88938     try {
88939       delete arg1;
88940     } catch (std::out_of_range& e) {
88941       {
88942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88943       };
88944     } catch (std::exception& e) {
88945       {
88946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88947       };
88948     } catch (Dali::DaliException e) {
88949       {
88950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88951       };
88952     } catch (...) {
88953       {
88954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88955       };
88956     }
88957   }
88958
88959 }
88960
88961
88962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88963   void * jresult ;
88964   Dali::BaseHandle arg1 ;
88965   Dali::BaseHandle *argp1 ;
88966   Dali::Toolkit::ProgressBar result;
88967
88968   argp1 = (Dali::BaseHandle *)jarg1;
88969   if (!argp1) {
88970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88971     return 0;
88972   }
88973   arg1 = *argp1;
88974   {
88975     try {
88976       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88977     } catch (std::out_of_range& e) {
88978       {
88979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88980       };
88981     } catch (std::exception& e) {
88982       {
88983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88984       };
88985     } catch (Dali::DaliException e) {
88986       {
88987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88988       };
88989     } catch (...) {
88990       {
88991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88992       };
88993     }
88994   }
88995
88996   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88997   return jresult;
88998 }
88999
89000
89001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89002   void * jresult ;
89003   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89004   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89005
89006   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89007   {
89008     try {
89009       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89010     } catch (std::out_of_range& e) {
89011       {
89012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89013       };
89014     } catch (std::exception& e) {
89015       {
89016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89017       };
89018     } catch (Dali::DaliException e) {
89019       {
89020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89021       };
89022     } catch (...) {
89023       {
89024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89025       };
89026     }
89027   }
89028
89029   jresult = (void *)result;
89030   return jresult;
89031 }
89032
89033
89034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89035   void * jresult ;
89036   Dali::Toolkit::GaussianBlurView *result = 0 ;
89037
89038   {
89039     try {
89040       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89041     } catch (std::out_of_range& e) {
89042       {
89043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89044       };
89045     } catch (std::exception& e) {
89046       {
89047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89048       };
89049     } catch (Dali::DaliException e) {
89050       {
89051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89052       };
89053     } catch (...) {
89054       {
89055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89056       };
89057     }
89058   }
89059
89060   jresult = (void *)result;
89061   return jresult;
89062 }
89063
89064
89065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89066   void * jresult ;
89067   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89068   Dali::Toolkit::GaussianBlurView *result = 0 ;
89069
89070   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89071   if (!arg1) {
89072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89073     return 0;
89074   }
89075   {
89076     try {
89077       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89078     } catch (std::out_of_range& e) {
89079       {
89080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89081       };
89082     } catch (std::exception& e) {
89083       {
89084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89085       };
89086     } catch (Dali::DaliException e) {
89087       {
89088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89089       };
89090     } catch (...) {
89091       {
89092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89093       };
89094     }
89095   }
89096
89097   jresult = (void *)result;
89098   return jresult;
89099 }
89100
89101
89102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89103   void * jresult ;
89104   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89105   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89106   Dali::Toolkit::GaussianBlurView *result = 0 ;
89107
89108   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89109   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89110   if (!arg2) {
89111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89112     return 0;
89113   }
89114   {
89115     try {
89116       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89117     } catch (std::out_of_range& e) {
89118       {
89119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89120       };
89121     } catch (std::exception& e) {
89122       {
89123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89124       };
89125     } catch (Dali::DaliException e) {
89126       {
89127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89128       };
89129     } catch (...) {
89130       {
89131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89132       };
89133     }
89134   }
89135
89136   jresult = (void *)result;
89137   return jresult;
89138 }
89139
89140
89141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89142   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89143
89144   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89145   {
89146     try {
89147       delete arg1;
89148     } catch (std::out_of_range& e) {
89149       {
89150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89151       };
89152     } catch (std::exception& e) {
89153       {
89154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89155       };
89156     } catch (Dali::DaliException e) {
89157       {
89158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89159       };
89160     } catch (...) {
89161       {
89162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89163       };
89164     }
89165   }
89166
89167 }
89168
89169
89170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89171   void * jresult ;
89172   Dali::BaseHandle arg1 ;
89173   Dali::BaseHandle *argp1 ;
89174   Dali::Toolkit::GaussianBlurView result;
89175
89176   argp1 = (Dali::BaseHandle *)jarg1;
89177   if (!argp1) {
89178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89179     return 0;
89180   }
89181   arg1 = *argp1;
89182   {
89183     try {
89184       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89185     } catch (std::out_of_range& e) {
89186       {
89187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89188       };
89189     } catch (std::exception& e) {
89190       {
89191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89192       };
89193     } catch (Dali::DaliException e) {
89194       {
89195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89196       };
89197     } catch (...) {
89198       {
89199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89200       };
89201     }
89202   }
89203
89204   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89205   return jresult;
89206 }
89207
89208
89209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89210   void * jresult ;
89211   Dali::Toolkit::GaussianBlurView result;
89212
89213   {
89214     try {
89215       result = Dali::Toolkit::GaussianBlurView::New();
89216     } catch (std::out_of_range& e) {
89217       {
89218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89219       };
89220     } catch (std::exception& e) {
89221       {
89222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89223       };
89224     } catch (Dali::DaliException e) {
89225       {
89226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89227       };
89228     } catch (...) {
89229       {
89230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89231       };
89232     }
89233   }
89234
89235   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89236   return jresult;
89237 }
89238
89239
89240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89241   void * jresult ;
89242   unsigned int arg1 ;
89243   float arg2 ;
89244   Dali::Pixel::Format arg3 ;
89245   float arg4 ;
89246   float arg5 ;
89247   bool arg6 ;
89248   Dali::Toolkit::GaussianBlurView result;
89249
89250   arg1 = (unsigned int)jarg1;
89251   arg2 = (float)jarg2;
89252   arg3 = (Dali::Pixel::Format)jarg3;
89253   arg4 = (float)jarg4;
89254   arg5 = (float)jarg5;
89255   arg6 = jarg6 ? true : false;
89256   {
89257     try {
89258       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89259     } catch (std::out_of_range& e) {
89260       {
89261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89262       };
89263     } catch (std::exception& e) {
89264       {
89265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89266       };
89267     } catch (Dali::DaliException e) {
89268       {
89269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89270       };
89271     } catch (...) {
89272       {
89273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89274       };
89275     }
89276   }
89277
89278   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89279   return jresult;
89280 }
89281
89282
89283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89284   void * jresult ;
89285   unsigned int arg1 ;
89286   float arg2 ;
89287   Dali::Pixel::Format arg3 ;
89288   float arg4 ;
89289   float arg5 ;
89290   Dali::Toolkit::GaussianBlurView result;
89291
89292   arg1 = (unsigned int)jarg1;
89293   arg2 = (float)jarg2;
89294   arg3 = (Dali::Pixel::Format)jarg3;
89295   arg4 = (float)jarg4;
89296   arg5 = (float)jarg5;
89297   {
89298     try {
89299       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89300     } catch (std::out_of_range& e) {
89301       {
89302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89303       };
89304     } catch (std::exception& e) {
89305       {
89306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89307       };
89308     } catch (Dali::DaliException e) {
89309       {
89310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89311       };
89312     } catch (...) {
89313       {
89314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89315       };
89316     }
89317   }
89318
89319   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89320   return jresult;
89321 }
89322
89323
89324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89325   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89326   Dali::Actor arg2 ;
89327   Dali::Actor *argp2 ;
89328
89329   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89330   argp2 = (Dali::Actor *)jarg2;
89331   if (!argp2) {
89332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89333     return ;
89334   }
89335   arg2 = *argp2;
89336   {
89337     try {
89338       (arg1)->Add(arg2);
89339     } catch (std::out_of_range& e) {
89340       {
89341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89342       };
89343     } catch (std::exception& e) {
89344       {
89345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89346       };
89347     } catch (Dali::DaliException e) {
89348       {
89349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89350       };
89351     } catch (...) {
89352       {
89353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89354       };
89355     }
89356   }
89357
89358 }
89359
89360
89361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89362   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89363   Dali::Actor arg2 ;
89364   Dali::Actor *argp2 ;
89365
89366   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89367   argp2 = (Dali::Actor *)jarg2;
89368   if (!argp2) {
89369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89370     return ;
89371   }
89372   arg2 = *argp2;
89373   {
89374     try {
89375       (arg1)->Remove(arg2);
89376     } catch (std::out_of_range& e) {
89377       {
89378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89379       };
89380     } catch (std::exception& e) {
89381       {
89382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89383       };
89384     } catch (Dali::DaliException e) {
89385       {
89386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89387       };
89388     } catch (...) {
89389       {
89390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89391       };
89392     }
89393   }
89394
89395 }
89396
89397
89398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89399   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89400
89401   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89402   {
89403     try {
89404       (arg1)->Activate();
89405     } catch (std::out_of_range& e) {
89406       {
89407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89408       };
89409     } catch (std::exception& e) {
89410       {
89411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89412       };
89413     } catch (Dali::DaliException e) {
89414       {
89415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89416       };
89417     } catch (...) {
89418       {
89419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89420       };
89421     }
89422   }
89423
89424 }
89425
89426
89427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89428   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89429
89430   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89431   {
89432     try {
89433       (arg1)->ActivateOnce();
89434     } catch (std::out_of_range& e) {
89435       {
89436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89437       };
89438     } catch (std::exception& e) {
89439       {
89440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89441       };
89442     } catch (Dali::DaliException e) {
89443       {
89444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89445       };
89446     } catch (...) {
89447       {
89448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89449       };
89450     }
89451   }
89452
89453 }
89454
89455
89456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89457   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89458
89459   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89460   {
89461     try {
89462       (arg1)->Deactivate();
89463     } catch (std::out_of_range& e) {
89464       {
89465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89466       };
89467     } catch (std::exception& e) {
89468       {
89469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89470       };
89471     } catch (Dali::DaliException e) {
89472       {
89473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89474       };
89475     } catch (...) {
89476       {
89477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89478       };
89479     }
89480   }
89481
89482 }
89483
89484
89485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89486   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89487   Dali::Image arg2 ;
89488   Dali::FrameBufferImage arg3 ;
89489   Dali::Image *argp2 ;
89490   Dali::FrameBufferImage *argp3 ;
89491
89492   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89493   argp2 = (Dali::Image *)jarg2;
89494   if (!argp2) {
89495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89496     return ;
89497   }
89498   arg2 = *argp2;
89499   argp3 = (Dali::FrameBufferImage *)jarg3;
89500   if (!argp3) {
89501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89502     return ;
89503   }
89504   arg3 = *argp3;
89505   {
89506     try {
89507       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89508     } catch (std::out_of_range& e) {
89509       {
89510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89511       };
89512     } catch (std::exception& e) {
89513       {
89514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89515       };
89516     } catch (Dali::DaliException e) {
89517       {
89518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89519       };
89520     } catch (...) {
89521       {
89522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89523       };
89524     }
89525   }
89526
89527 }
89528
89529
89530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89531   int jresult ;
89532   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89533   Dali::Property::Index result;
89534
89535   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89536   {
89537     try {
89538       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89539     } catch (std::out_of_range& e) {
89540       {
89541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89542       };
89543     } catch (std::exception& e) {
89544       {
89545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89546       };
89547     } catch (Dali::DaliException e) {
89548       {
89549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89550       };
89551     } catch (...) {
89552       {
89553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89554       };
89555     }
89556   }
89557
89558   jresult = result;
89559   return jresult;
89560 }
89561
89562
89563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89564   void * jresult ;
89565   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89566   Dali::FrameBufferImage result;
89567
89568   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89569   {
89570     try {
89571       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89572     } catch (std::out_of_range& e) {
89573       {
89574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89575       };
89576     } catch (std::exception& e) {
89577       {
89578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89579       };
89580     } catch (Dali::DaliException e) {
89581       {
89582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89583       };
89584     } catch (...) {
89585       {
89586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89587       };
89588     }
89589   }
89590
89591   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89592   return jresult;
89593 }
89594
89595
89596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89597   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89598   Dali::Vector4 *arg2 = 0 ;
89599
89600   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89601   arg2 = (Dali::Vector4 *)jarg2;
89602   if (!arg2) {
89603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89604     return ;
89605   }
89606   {
89607     try {
89608       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89609     } catch (std::out_of_range& e) {
89610       {
89611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89612       };
89613     } catch (std::exception& e) {
89614       {
89615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89616       };
89617     } catch (Dali::DaliException e) {
89618       {
89619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89620       };
89621     } catch (...) {
89622       {
89623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89624       };
89625     }
89626   }
89627
89628 }
89629
89630
89631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89632   void * jresult ;
89633   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89634   Dali::Vector4 result;
89635
89636   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89637   {
89638     try {
89639       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89640     } catch (std::out_of_range& e) {
89641       {
89642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89643       };
89644     } catch (std::exception& e) {
89645       {
89646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89647       };
89648     } catch (Dali::DaliException e) {
89649       {
89650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89651       };
89652     } catch (...) {
89653       {
89654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89655       };
89656     }
89657   }
89658
89659   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89660   return jresult;
89661 }
89662
89663
89664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89665   void * jresult ;
89666   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89667   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89668
89669   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89670   {
89671     try {
89672       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89673     } catch (std::out_of_range& e) {
89674       {
89675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89676       };
89677     } catch (std::exception& e) {
89678       {
89679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89680       };
89681     } catch (Dali::DaliException e) {
89682       {
89683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89684       };
89685     } catch (...) {
89686       {
89687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89688       };
89689     }
89690   }
89691
89692   jresult = (void *)result;
89693   return jresult;
89694 }
89695
89696
89697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89698   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89699
89700   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89701   {
89702     try {
89703       delete arg1;
89704     } catch (std::out_of_range& e) {
89705       {
89706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89707       };
89708     } catch (std::exception& e) {
89709       {
89710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89711       };
89712     } catch (Dali::DaliException e) {
89713       {
89714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89715       };
89716     } catch (...) {
89717       {
89718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89719       };
89720     }
89721   }
89722
89723 }
89724
89725
89726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89727   unsigned int jresult ;
89728   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89729   unsigned int result;
89730
89731   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89732   {
89733     try {
89734       result = (unsigned int)(arg1)->GetNumberOfPages();
89735     } catch (std::out_of_range& e) {
89736       {
89737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89738       };
89739     } catch (std::exception& e) {
89740       {
89741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89742       };
89743     } catch (Dali::DaliException e) {
89744       {
89745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89746       };
89747     } catch (...) {
89748       {
89749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89750       };
89751     }
89752   }
89753
89754   jresult = result;
89755   return jresult;
89756 }
89757
89758
89759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89760   void * jresult ;
89761   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89762   unsigned int arg2 ;
89763   Dali::Texture result;
89764
89765   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89766   arg2 = (unsigned int)jarg2;
89767   {
89768     try {
89769       result = (arg1)->NewPage(arg2);
89770     } catch (std::out_of_range& e) {
89771       {
89772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89773       };
89774     } catch (std::exception& e) {
89775       {
89776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89777       };
89778     } catch (Dali::DaliException e) {
89779       {
89780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89781       };
89782     } catch (...) {
89783       {
89784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89785       };
89786     }
89787   }
89788
89789   jresult = new Dali::Texture((const Dali::Texture &)result);
89790   return jresult;
89791 }
89792
89793
89794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89795   int jresult ;
89796   int result;
89797
89798   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89799   jresult = (int)result;
89800   return jresult;
89801 }
89802
89803
89804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89805   int jresult ;
89806   int result;
89807
89808   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89809   jresult = (int)result;
89810   return jresult;
89811 }
89812
89813
89814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89815   int jresult ;
89816   int result;
89817
89818   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89819   jresult = (int)result;
89820   return jresult;
89821 }
89822
89823
89824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89825   void * jresult ;
89826   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89827
89828   {
89829     try {
89830       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89831     } catch (std::out_of_range& e) {
89832       {
89833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89834       };
89835     } catch (std::exception& e) {
89836       {
89837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89838       };
89839     } catch (Dali::DaliException e) {
89840       {
89841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89842       };
89843     } catch (...) {
89844       {
89845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89846       };
89847     }
89848   }
89849
89850   jresult = (void *)result;
89851   return jresult;
89852 }
89853
89854
89855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89856   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89857
89858   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89859   {
89860     try {
89861       delete arg1;
89862     } catch (std::out_of_range& e) {
89863       {
89864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89865       };
89866     } catch (std::exception& e) {
89867       {
89868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89869       };
89870     } catch (Dali::DaliException e) {
89871       {
89872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89873       };
89874     } catch (...) {
89875       {
89876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89877       };
89878     }
89879   }
89880
89881 }
89882
89883
89884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89885   void * jresult ;
89886   Dali::Toolkit::PageTurnView *result = 0 ;
89887
89888   {
89889     try {
89890       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89891     } catch (std::out_of_range& e) {
89892       {
89893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89894       };
89895     } catch (std::exception& e) {
89896       {
89897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89898       };
89899     } catch (Dali::DaliException e) {
89900       {
89901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89902       };
89903     } catch (...) {
89904       {
89905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89906       };
89907     }
89908   }
89909
89910   jresult = (void *)result;
89911   return jresult;
89912 }
89913
89914
89915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89916   void * jresult ;
89917   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89918   Dali::Toolkit::PageTurnView *result = 0 ;
89919
89920   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89921   if (!arg1) {
89922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89923     return 0;
89924   }
89925   {
89926     try {
89927       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89928     } catch (std::out_of_range& e) {
89929       {
89930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89931       };
89932     } catch (std::exception& e) {
89933       {
89934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89935       };
89936     } catch (Dali::DaliException e) {
89937       {
89938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89939       };
89940     } catch (...) {
89941       {
89942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89943       };
89944     }
89945   }
89946
89947   jresult = (void *)result;
89948   return jresult;
89949 }
89950
89951
89952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89953   void * jresult ;
89954   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89955   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89956   Dali::Toolkit::PageTurnView *result = 0 ;
89957
89958   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89959   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89960   if (!arg2) {
89961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89962     return 0;
89963   }
89964   {
89965     try {
89966       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89967     } catch (std::out_of_range& e) {
89968       {
89969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89970       };
89971     } catch (std::exception& e) {
89972       {
89973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89974       };
89975     } catch (Dali::DaliException e) {
89976       {
89977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89978       };
89979     } catch (...) {
89980       {
89981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89982       };
89983     }
89984   }
89985
89986   jresult = (void *)result;
89987   return jresult;
89988 }
89989
89990
89991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89992   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89993
89994   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89995   {
89996     try {
89997       delete arg1;
89998     } catch (std::out_of_range& e) {
89999       {
90000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90001       };
90002     } catch (std::exception& e) {
90003       {
90004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90005       };
90006     } catch (Dali::DaliException e) {
90007       {
90008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90009       };
90010     } catch (...) {
90011       {
90012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90013       };
90014     }
90015   }
90016
90017 }
90018
90019
90020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90021   void * jresult ;
90022   Dali::BaseHandle arg1 ;
90023   Dali::BaseHandle *argp1 ;
90024   Dali::Toolkit::PageTurnView result;
90025
90026   argp1 = (Dali::BaseHandle *)jarg1;
90027   if (!argp1) {
90028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90029     return 0;
90030   }
90031   arg1 = *argp1;
90032   {
90033     try {
90034       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90035     } catch (std::out_of_range& e) {
90036       {
90037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90038       };
90039     } catch (std::exception& e) {
90040       {
90041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90042       };
90043     } catch (Dali::DaliException e) {
90044       {
90045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90046       };
90047     } catch (...) {
90048       {
90049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90050       };
90051     }
90052   }
90053
90054   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90055   return jresult;
90056 }
90057
90058
90059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90060   void * jresult ;
90061   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90062   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90063
90064   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90065   {
90066     try {
90067       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90068     } catch (std::out_of_range& e) {
90069       {
90070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90071       };
90072     } catch (std::exception& e) {
90073       {
90074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90075       };
90076     } catch (Dali::DaliException e) {
90077       {
90078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90079       };
90080     } catch (...) {
90081       {
90082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90083       };
90084     }
90085   }
90086
90087   jresult = (void *)result;
90088   return jresult;
90089 }
90090
90091
90092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90093   void * jresult ;
90094   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90095   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90096
90097   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90098   {
90099     try {
90100       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90101     } catch (std::out_of_range& e) {
90102       {
90103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90104       };
90105     } catch (std::exception& e) {
90106       {
90107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90108       };
90109     } catch (Dali::DaliException e) {
90110       {
90111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90112       };
90113     } catch (...) {
90114       {
90115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90116       };
90117     }
90118   }
90119
90120   jresult = (void *)result;
90121   return jresult;
90122 }
90123
90124
90125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90126   void * jresult ;
90127   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90128   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90129
90130   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90131   {
90132     try {
90133       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90134     } catch (std::out_of_range& e) {
90135       {
90136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90137       };
90138     } catch (std::exception& e) {
90139       {
90140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90141       };
90142     } catch (Dali::DaliException e) {
90143       {
90144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90145       };
90146     } catch (...) {
90147       {
90148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90149       };
90150     }
90151   }
90152
90153   jresult = (void *)result;
90154   return jresult;
90155 }
90156
90157
90158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90159   void * jresult ;
90160   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90161   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90162
90163   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90164   {
90165     try {
90166       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90167     } catch (std::out_of_range& e) {
90168       {
90169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90170       };
90171     } catch (std::exception& e) {
90172       {
90173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90174       };
90175     } catch (Dali::DaliException e) {
90176       {
90177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90178       };
90179     } catch (...) {
90180       {
90181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90182       };
90183     }
90184   }
90185
90186   jresult = (void *)result;
90187   return jresult;
90188 }
90189
90190
90191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90192   void * jresult ;
90193   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90194
90195   {
90196     try {
90197       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90198     } catch (std::out_of_range& e) {
90199       {
90200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90201       };
90202     } catch (std::exception& e) {
90203       {
90204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90205       };
90206     } catch (Dali::DaliException e) {
90207       {
90208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90209       };
90210     } catch (...) {
90211       {
90212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90213       };
90214     }
90215   }
90216
90217   jresult = (void *)result;
90218   return jresult;
90219 }
90220
90221
90222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90223   void * jresult ;
90224   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90225   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90226
90227   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90228   if (!arg1) {
90229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90230     return 0;
90231   }
90232   {
90233     try {
90234       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90235     } catch (std::out_of_range& e) {
90236       {
90237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90238       };
90239     } catch (std::exception& e) {
90240       {
90241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90242       };
90243     } catch (Dali::DaliException e) {
90244       {
90245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90246       };
90247     } catch (...) {
90248       {
90249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90250       };
90251     }
90252   }
90253
90254   jresult = (void *)result;
90255   return jresult;
90256 }
90257
90258
90259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90260   void * jresult ;
90261   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90262   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90263   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90264
90265   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90266   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90267   if (!arg2) {
90268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90269     return 0;
90270   }
90271   {
90272     try {
90273       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90274     } catch (std::out_of_range& e) {
90275       {
90276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90277       };
90278     } catch (std::exception& e) {
90279       {
90280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90281       };
90282     } catch (Dali::DaliException e) {
90283       {
90284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90285       };
90286     } catch (...) {
90287       {
90288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90289       };
90290     }
90291   }
90292
90293   jresult = (void *)result;
90294   return jresult;
90295 }
90296
90297
90298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90299   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90300
90301   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90302   {
90303     try {
90304       delete arg1;
90305     } catch (std::out_of_range& e) {
90306       {
90307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90308       };
90309     } catch (std::exception& e) {
90310       {
90311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90312       };
90313     } catch (Dali::DaliException e) {
90314       {
90315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90316       };
90317     } catch (...) {
90318       {
90319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90320       };
90321     }
90322   }
90323
90324 }
90325
90326
90327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90328   void * jresult ;
90329   Dali::Toolkit::PageFactory *arg1 = 0 ;
90330   Dali::Vector2 *arg2 = 0 ;
90331   Dali::Toolkit::PageTurnLandscapeView result;
90332
90333   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90334   if (!arg1) {
90335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90336     return 0;
90337   }
90338   arg2 = (Dali::Vector2 *)jarg2;
90339   if (!arg2) {
90340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90341     return 0;
90342   }
90343   {
90344     try {
90345       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90346     } catch (std::out_of_range& e) {
90347       {
90348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90349       };
90350     } catch (std::exception& e) {
90351       {
90352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90353       };
90354     } catch (Dali::DaliException e) {
90355       {
90356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90357       };
90358     } catch (...) {
90359       {
90360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90361       };
90362     }
90363   }
90364
90365   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90366   return jresult;
90367 }
90368
90369
90370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90371   void * jresult ;
90372   Dali::BaseHandle arg1 ;
90373   Dali::BaseHandle *argp1 ;
90374   Dali::Toolkit::PageTurnLandscapeView result;
90375
90376   argp1 = (Dali::BaseHandle *)jarg1;
90377   if (!argp1) {
90378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90379     return 0;
90380   }
90381   arg1 = *argp1;
90382   {
90383     try {
90384       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90385     } catch (std::out_of_range& e) {
90386       {
90387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90388       };
90389     } catch (std::exception& e) {
90390       {
90391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90392       };
90393     } catch (Dali::DaliException e) {
90394       {
90395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90396       };
90397     } catch (...) {
90398       {
90399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90400       };
90401     }
90402   }
90403
90404   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90405   return jresult;
90406 }
90407
90408
90409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90410   void * jresult ;
90411   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90412
90413   {
90414     try {
90415       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90416     } catch (std::out_of_range& e) {
90417       {
90418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90419       };
90420     } catch (std::exception& e) {
90421       {
90422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90423       };
90424     } catch (Dali::DaliException e) {
90425       {
90426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90427       };
90428     } catch (...) {
90429       {
90430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90431       };
90432     }
90433   }
90434
90435   jresult = (void *)result;
90436   return jresult;
90437 }
90438
90439
90440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90441   void * jresult ;
90442   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90443   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90444
90445   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90446   if (!arg1) {
90447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90448     return 0;
90449   }
90450   {
90451     try {
90452       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90453     } catch (std::out_of_range& e) {
90454       {
90455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90456       };
90457     } catch (std::exception& e) {
90458       {
90459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90460       };
90461     } catch (Dali::DaliException e) {
90462       {
90463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90464       };
90465     } catch (...) {
90466       {
90467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90468       };
90469     }
90470   }
90471
90472   jresult = (void *)result;
90473   return jresult;
90474 }
90475
90476
90477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90478   void * jresult ;
90479   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90480   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90481   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90482
90483   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90484   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90485   if (!arg2) {
90486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90487     return 0;
90488   }
90489   {
90490     try {
90491       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90492     } catch (std::out_of_range& e) {
90493       {
90494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90495       };
90496     } catch (std::exception& e) {
90497       {
90498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90499       };
90500     } catch (Dali::DaliException e) {
90501       {
90502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90503       };
90504     } catch (...) {
90505       {
90506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90507       };
90508     }
90509   }
90510
90511   jresult = (void *)result;
90512   return jresult;
90513 }
90514
90515
90516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90517   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90518
90519   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90520   {
90521     try {
90522       delete arg1;
90523     } catch (std::out_of_range& e) {
90524       {
90525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90526       };
90527     } catch (std::exception& e) {
90528       {
90529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90530       };
90531     } catch (Dali::DaliException e) {
90532       {
90533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90534       };
90535     } catch (...) {
90536       {
90537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90538       };
90539     }
90540   }
90541
90542 }
90543
90544
90545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90546   void * jresult ;
90547   Dali::Toolkit::PageFactory *arg1 = 0 ;
90548   Dali::Vector2 *arg2 = 0 ;
90549   Dali::Toolkit::PageTurnPortraitView result;
90550
90551   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90552   if (!arg1) {
90553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90554     return 0;
90555   }
90556   arg2 = (Dali::Vector2 *)jarg2;
90557   if (!arg2) {
90558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90559     return 0;
90560   }
90561   {
90562     try {
90563       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90564     } catch (std::out_of_range& e) {
90565       {
90566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90567       };
90568     } catch (std::exception& e) {
90569       {
90570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90571       };
90572     } catch (Dali::DaliException e) {
90573       {
90574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90575       };
90576     } catch (...) {
90577       {
90578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90579       };
90580     }
90581   }
90582
90583   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90584   return jresult;
90585 }
90586
90587
90588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90589   void * jresult ;
90590   Dali::BaseHandle arg1 ;
90591   Dali::BaseHandle *argp1 ;
90592   Dali::Toolkit::PageTurnPortraitView result;
90593
90594   argp1 = (Dali::BaseHandle *)jarg1;
90595   if (!argp1) {
90596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90597     return 0;
90598   }
90599   arg1 = *argp1;
90600   {
90601     try {
90602       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90603     } catch (std::out_of_range& e) {
90604       {
90605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90606       };
90607     } catch (std::exception& e) {
90608       {
90609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90610       };
90611     } catch (Dali::DaliException e) {
90612       {
90613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90614       };
90615     } catch (...) {
90616       {
90617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90618       };
90619     }
90620   }
90621
90622   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90623   return jresult;
90624 }
90625
90626
90627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90628   int jresult ;
90629   int result;
90630
90631   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90632   jresult = (int)result;
90633   return jresult;
90634 }
90635
90636
90637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90638   int jresult ;
90639   int result;
90640
90641   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90642   jresult = (int)result;
90643   return jresult;
90644 }
90645
90646
90647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90648   int jresult ;
90649   int result;
90650
90651   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90652   jresult = (int)result;
90653   return jresult;
90654 }
90655
90656
90657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90658   void * jresult ;
90659   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90660
90661   {
90662     try {
90663       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90664     } catch (std::out_of_range& e) {
90665       {
90666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90667       };
90668     } catch (std::exception& e) {
90669       {
90670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90671       };
90672     } catch (Dali::DaliException e) {
90673       {
90674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90675       };
90676     } catch (...) {
90677       {
90678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90679       };
90680     }
90681   }
90682
90683   jresult = (void *)result;
90684   return jresult;
90685 }
90686
90687
90688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90689   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90690
90691   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90692   {
90693     try {
90694       delete arg1;
90695     } catch (std::out_of_range& e) {
90696       {
90697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90698       };
90699     } catch (std::exception& e) {
90700       {
90701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90702       };
90703     } catch (Dali::DaliException e) {
90704       {
90705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90706       };
90707     } catch (...) {
90708       {
90709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90710       };
90711     }
90712   }
90713
90714 }
90715
90716
90717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90718   void * jresult ;
90719   Dali::Toolkit::ToggleButton *result = 0 ;
90720
90721   {
90722     try {
90723       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90724     } catch (std::out_of_range& e) {
90725       {
90726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90727       };
90728     } catch (std::exception& e) {
90729       {
90730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90731       };
90732     } catch (Dali::DaliException e) {
90733       {
90734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90735       };
90736     } catch (...) {
90737       {
90738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90739       };
90740     }
90741   }
90742
90743   jresult = (void *)result;
90744   return jresult;
90745 }
90746
90747
90748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90749   void * jresult ;
90750   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90751   Dali::Toolkit::ToggleButton *result = 0 ;
90752
90753   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90754   if (!arg1) {
90755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90756     return 0;
90757   }
90758   {
90759     try {
90760       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90761     } catch (std::out_of_range& e) {
90762       {
90763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90764       };
90765     } catch (std::exception& e) {
90766       {
90767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90768       };
90769     } catch (Dali::DaliException e) {
90770       {
90771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90772       };
90773     } catch (...) {
90774       {
90775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90776       };
90777     }
90778   }
90779
90780   jresult = (void *)result;
90781   return jresult;
90782 }
90783
90784
90785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90786   void * jresult ;
90787   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90788   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90789   Dali::Toolkit::ToggleButton *result = 0 ;
90790
90791   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90792   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90793   if (!arg2) {
90794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90795     return 0;
90796   }
90797   {
90798     try {
90799       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90800     } catch (std::out_of_range& e) {
90801       {
90802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90803       };
90804     } catch (std::exception& e) {
90805       {
90806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90807       };
90808     } catch (Dali::DaliException e) {
90809       {
90810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90811       };
90812     } catch (...) {
90813       {
90814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90815       };
90816     }
90817   }
90818
90819   jresult = (void *)result;
90820   return jresult;
90821 }
90822
90823
90824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90825   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90826
90827   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90828   {
90829     try {
90830       delete arg1;
90831     } catch (std::out_of_range& e) {
90832       {
90833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90834       };
90835     } catch (std::exception& e) {
90836       {
90837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90838       };
90839     } catch (Dali::DaliException e) {
90840       {
90841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90842       };
90843     } catch (...) {
90844       {
90845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90846       };
90847     }
90848   }
90849
90850 }
90851
90852
90853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90854   void * jresult ;
90855   Dali::Toolkit::ToggleButton result;
90856
90857   {
90858     try {
90859       result = Dali::Toolkit::ToggleButton::New();
90860     } catch (std::out_of_range& e) {
90861       {
90862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90863       };
90864     } catch (std::exception& e) {
90865       {
90866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90867       };
90868     } catch (Dali::DaliException e) {
90869       {
90870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90871       };
90872     } catch (...) {
90873       {
90874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90875       };
90876     }
90877   }
90878
90879   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90880   return jresult;
90881 }
90882
90883
90884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90885   void * jresult ;
90886   Dali::BaseHandle arg1 ;
90887   Dali::BaseHandle *argp1 ;
90888   Dali::Toolkit::ToggleButton result;
90889
90890   argp1 = (Dali::BaseHandle *)jarg1;
90891   if (!argp1) {
90892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90893     return 0;
90894   }
90895   arg1 = *argp1;
90896   {
90897     try {
90898       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90899     } catch (std::out_of_range& e) {
90900       {
90901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90902       };
90903     } catch (std::exception& e) {
90904       {
90905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90906       };
90907     } catch (Dali::DaliException e) {
90908       {
90909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90910       };
90911     } catch (...) {
90912       {
90913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90914       };
90915     }
90916   }
90917
90918   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90919   return jresult;
90920 }
90921
90922
90923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90924   void * jresult ;
90925   Dali::Toolkit::Visual::Base *result = 0 ;
90926
90927   {
90928     try {
90929       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90930     } catch (std::out_of_range& e) {
90931       {
90932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90933       };
90934     } catch (std::exception& e) {
90935       {
90936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90937       };
90938     } catch (Dali::DaliException e) {
90939       {
90940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90941       };
90942     } catch (...) {
90943       {
90944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90945       };
90946     }
90947   }
90948
90949   jresult = (void *)result;
90950   return jresult;
90951 }
90952
90953
90954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90955   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90956
90957   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90958   {
90959     try {
90960       delete arg1;
90961     } catch (std::out_of_range& e) {
90962       {
90963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90964       };
90965     } catch (std::exception& e) {
90966       {
90967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90968       };
90969     } catch (Dali::DaliException e) {
90970       {
90971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90972       };
90973     } catch (...) {
90974       {
90975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90976       };
90977     }
90978   }
90979
90980 }
90981
90982
90983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90984   void * jresult ;
90985   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90986   Dali::Toolkit::Visual::Base *result = 0 ;
90987
90988   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90989   if (!arg1) {
90990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90991     return 0;
90992   }
90993   {
90994     try {
90995       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
90996     } catch (std::out_of_range& e) {
90997       {
90998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90999       };
91000     } catch (std::exception& e) {
91001       {
91002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91003       };
91004     } catch (Dali::DaliException e) {
91005       {
91006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91007       };
91008     } catch (...) {
91009       {
91010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91011       };
91012     }
91013   }
91014
91015   jresult = (void *)result;
91016   return jresult;
91017 }
91018
91019
91020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91021   void * jresult ;
91022   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91023   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91024   Dali::Toolkit::Visual::Base *result = 0 ;
91025
91026   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91027   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91028   if (!arg2) {
91029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91030     return 0;
91031   }
91032   {
91033     try {
91034       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91035     } catch (std::out_of_range& e) {
91036       {
91037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91038       };
91039     } catch (std::exception& e) {
91040       {
91041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91042       };
91043     } catch (Dali::DaliException e) {
91044       {
91045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91046       };
91047     } catch (...) {
91048       {
91049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91050       };
91051     }
91052   }
91053
91054   jresult = (void *)result;
91055   return jresult;
91056 }
91057
91058
91059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91060   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91061   std::string *arg2 = 0 ;
91062
91063   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91064   if (!jarg2) {
91065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91066     return ;
91067   }
91068   std::string arg2_str(jarg2);
91069   arg2 = &arg2_str;
91070   {
91071     try {
91072       (arg1)->SetName((std::string const &)*arg2);
91073     } catch (std::out_of_range& e) {
91074       {
91075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91076       };
91077     } catch (std::exception& e) {
91078       {
91079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91080       };
91081     } catch (Dali::DaliException e) {
91082       {
91083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91084       };
91085     } catch (...) {
91086       {
91087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91088       };
91089     }
91090   }
91091
91092
91093   //argout typemap for const std::string&
91094
91095 }
91096
91097
91098 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91099   char * jresult ;
91100   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91101   std::string *result = 0 ;
91102
91103   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91104   {
91105     try {
91106       result = (std::string *) &(arg1)->GetName();
91107     } catch (std::out_of_range& e) {
91108       {
91109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91110       };
91111     } catch (std::exception& e) {
91112       {
91113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91114       };
91115     } catch (Dali::DaliException e) {
91116       {
91117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91118       };
91119     } catch (...) {
91120       {
91121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91122       };
91123     }
91124   }
91125
91126   jresult = SWIG_csharp_string_callback(result->c_str());
91127   return jresult;
91128 }
91129
91130
91131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91132   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91133   Dali::Property::Map *arg2 = 0 ;
91134   Dali::Size arg3 ;
91135   Dali::Size *argp3 ;
91136
91137   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91138   arg2 = (Dali::Property::Map *)jarg2;
91139   if (!arg2) {
91140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91141     return ;
91142   }
91143   argp3 = (Dali::Size *)jarg3;
91144   if (!argp3) {
91145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91146     return ;
91147   }
91148   arg3 = *argp3;
91149   {
91150     try {
91151       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91152     } catch (std::out_of_range& e) {
91153       {
91154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91155       };
91156     } catch (std::exception& e) {
91157       {
91158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91159       };
91160     } catch (Dali::DaliException e) {
91161       {
91162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91163       };
91164     } catch (...) {
91165       {
91166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91167       };
91168     }
91169   }
91170
91171 }
91172
91173
91174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91175   float jresult ;
91176   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91177   float arg2 ;
91178   float result;
91179
91180   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91181   arg2 = (float)jarg2;
91182   {
91183     try {
91184       result = (float)(arg1)->GetHeightForWidth(arg2);
91185     } catch (std::out_of_range& e) {
91186       {
91187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91188       };
91189     } catch (std::exception& e) {
91190       {
91191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91192       };
91193     } catch (Dali::DaliException e) {
91194       {
91195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91196       };
91197     } catch (...) {
91198       {
91199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91200       };
91201     }
91202   }
91203
91204   jresult = result;
91205   return jresult;
91206 }
91207
91208
91209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91210   float jresult ;
91211   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91212   float arg2 ;
91213   float result;
91214
91215   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91216   arg2 = (float)jarg2;
91217   {
91218     try {
91219       result = (float)(arg1)->GetWidthForHeight(arg2);
91220     } catch (std::out_of_range& e) {
91221       {
91222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91223       };
91224     } catch (std::exception& e) {
91225       {
91226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91227       };
91228     } catch (Dali::DaliException e) {
91229       {
91230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91231       };
91232     } catch (...) {
91233       {
91234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91235       };
91236     }
91237   }
91238
91239   jresult = result;
91240   return jresult;
91241 }
91242
91243
91244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91245   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91246   Dali::Vector2 *arg2 = 0 ;
91247
91248   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91249   arg2 = (Dali::Vector2 *)jarg2;
91250   if (!arg2) {
91251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91252     return ;
91253   }
91254   {
91255     try {
91256       (arg1)->GetNaturalSize(*arg2);
91257     } catch (std::out_of_range& e) {
91258       {
91259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91260       };
91261     } catch (std::exception& e) {
91262       {
91263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91264       };
91265     } catch (Dali::DaliException e) {
91266       {
91267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91268       };
91269     } catch (...) {
91270       {
91271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91272       };
91273     }
91274   }
91275
91276 }
91277
91278
91279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91280   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91281   float arg2 ;
91282
91283   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91284   arg2 = (int)jarg2;
91285   {
91286     try {
91287       (arg1)->SetDepthIndex(arg2);
91288     } catch (std::out_of_range& e) {
91289       {
91290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91291       };
91292     } catch (std::exception& e) {
91293       {
91294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91295       };
91296     } catch (Dali::DaliException e) {
91297       {
91298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91299       };
91300     } catch (...) {
91301       {
91302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91303       };
91304     }
91305   }
91306
91307 }
91308
91309
91310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91311   int jresult ;
91312   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91313   int result;
91314
91315   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91316   {
91317     try {
91318       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91319     } catch (std::out_of_range& e) {
91320       {
91321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91322       };
91323     } catch (std::exception& e) {
91324       {
91325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91326       };
91327     } catch (Dali::DaliException e) {
91328       {
91329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91330       };
91331     } catch (...) {
91332       {
91333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91334       };
91335     }
91336   }
91337
91338   jresult = result;
91339   return jresult;
91340 }
91341
91342
91343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91344   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91345   Dali::Property::Map *arg2 = 0 ;
91346
91347   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91348   arg2 = (Dali::Property::Map *)jarg2;
91349   if (!arg2) {
91350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91351     return ;
91352   }
91353   {
91354     try {
91355       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91356     } catch (std::out_of_range& e) {
91357       {
91358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91359       };
91360     } catch (std::exception& e) {
91361       {
91362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91363       };
91364     } catch (Dali::DaliException e) {
91365       {
91366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91367       };
91368     } catch (...) {
91369       {
91370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91371       };
91372     }
91373   }
91374
91375 }
91376
91377
91378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
91379   void * jresult ;
91380   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
91381   Dali::Toolkit::Visual::Base *result = 0 ;
91382
91383   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
91384   {
91385     try {
91386       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
91387     } catch (std::out_of_range& e) {
91388       {
91389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91390       };
91391     } catch (std::exception& e) {
91392       {
91393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91394       };
91395     } catch (Dali::DaliException e) {
91396       {
91397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91398       };
91399     } catch (...) {
91400       {
91401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91402       };
91403     }
91404   }
91405
91406   jresult = (void *)result;
91407   return jresult;
91408 }
91409
91410
91411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91412   void * jresult ;
91413   Dali::Toolkit::VisualFactory result;
91414
91415   {
91416     try {
91417       result = Dali::Toolkit::VisualFactory::Get();
91418     } catch (std::out_of_range& e) {
91419       {
91420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91421       };
91422     } catch (std::exception& e) {
91423       {
91424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91425       };
91426     } catch (Dali::DaliException e) {
91427       {
91428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91429       };
91430     } catch (...) {
91431       {
91432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91433       };
91434     }
91435   }
91436
91437   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91438   return jresult;
91439 }
91440
91441
91442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91443   void * jresult ;
91444   Dali::Toolkit::VisualFactory *result = 0 ;
91445
91446   {
91447     try {
91448       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91449     } catch (std::out_of_range& e) {
91450       {
91451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91452       };
91453     } catch (std::exception& e) {
91454       {
91455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91456       };
91457     } catch (Dali::DaliException e) {
91458       {
91459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91460       };
91461     } catch (...) {
91462       {
91463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91464       };
91465     }
91466   }
91467
91468   jresult = (void *)result;
91469   return jresult;
91470 }
91471
91472
91473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91474   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91475
91476   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91477   {
91478     try {
91479       delete arg1;
91480     } catch (std::out_of_range& e) {
91481       {
91482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91483       };
91484     } catch (std::exception& e) {
91485       {
91486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91487       };
91488     } catch (Dali::DaliException e) {
91489       {
91490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91491       };
91492     } catch (...) {
91493       {
91494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91495       };
91496     }
91497   }
91498
91499 }
91500
91501
91502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91503   void * jresult ;
91504   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91505   Dali::Toolkit::VisualFactory *result = 0 ;
91506
91507   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91508   if (!arg1) {
91509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91510     return 0;
91511   }
91512   {
91513     try {
91514       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91515     } catch (std::out_of_range& e) {
91516       {
91517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91518       };
91519     } catch (std::exception& e) {
91520       {
91521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91522       };
91523     } catch (Dali::DaliException e) {
91524       {
91525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91526       };
91527     } catch (...) {
91528       {
91529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91530       };
91531     }
91532   }
91533
91534   jresult = (void *)result;
91535   return jresult;
91536 }
91537
91538
91539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91540   void * jresult ;
91541   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91542   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91543   Dali::Toolkit::VisualFactory *result = 0 ;
91544
91545   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91546   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91547   if (!arg2) {
91548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91549     return 0;
91550   }
91551   {
91552     try {
91553       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91554     } catch (std::out_of_range& e) {
91555       {
91556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91557       };
91558     } catch (std::exception& e) {
91559       {
91560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91561       };
91562     } catch (Dali::DaliException e) {
91563       {
91564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91565       };
91566     } catch (...) {
91567       {
91568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91569       };
91570     }
91571   }
91572
91573   jresult = (void *)result;
91574   return jresult;
91575 }
91576
91577
91578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91579   void * jresult ;
91580   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91581   Dali::Property::Map *arg2 = 0 ;
91582   Dali::Toolkit::Visual::Base result;
91583
91584   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91585   arg2 = (Dali::Property::Map *)jarg2;
91586   if (!arg2) {
91587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91588     return 0;
91589   }
91590   {
91591     try {
91592       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91593     } catch (std::out_of_range& e) {
91594       {
91595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91596       };
91597     } catch (std::exception& e) {
91598       {
91599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91600       };
91601     } catch (Dali::DaliException e) {
91602       {
91603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91604       };
91605     } catch (...) {
91606       {
91607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91608       };
91609     }
91610   }
91611
91612   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91613   return jresult;
91614 }
91615
91616
91617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91618   void * jresult ;
91619   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91620   Dali::Image *arg2 = 0 ;
91621   Dali::Toolkit::Visual::Base result;
91622
91623   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91624   arg2 = (Dali::Image *)jarg2;
91625   if (!arg2) {
91626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91627     return 0;
91628   }
91629   {
91630     try {
91631       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91632     } catch (std::out_of_range& e) {
91633       {
91634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91635       };
91636     } catch (std::exception& e) {
91637       {
91638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91639       };
91640     } catch (Dali::DaliException e) {
91641       {
91642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91643       };
91644     } catch (...) {
91645       {
91646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91647       };
91648     }
91649   }
91650
91651   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91652   return jresult;
91653 }
91654
91655
91656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91657   void * jresult ;
91658   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91659   std::string *arg2 = 0 ;
91660   Dali::ImageDimensions arg3 ;
91661   Dali::ImageDimensions *argp3 ;
91662   Dali::Toolkit::Visual::Base result;
91663
91664   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91665   if (!jarg2) {
91666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91667     return 0;
91668   }
91669   std::string arg2_str(jarg2);
91670   arg2 = &arg2_str;
91671   argp3 = (Dali::ImageDimensions *)jarg3;
91672   if (!argp3) {
91673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91674     return 0;
91675   }
91676   arg3 = *argp3;
91677   {
91678     try {
91679       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91680     } catch (std::out_of_range& e) {
91681       {
91682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91683       };
91684     } catch (std::exception& e) {
91685       {
91686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91687       };
91688     } catch (Dali::DaliException e) {
91689       {
91690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91691       };
91692     } catch (...) {
91693       {
91694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91695       };
91696     }
91697   }
91698
91699   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91700
91701   //argout typemap for const std::string&
91702
91703   return jresult;
91704 }
91705
91706
91707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91708   void * jresult ;
91709   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91710
91711   {
91712     try {
91713       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91714     } catch (std::out_of_range& e) {
91715       {
91716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91717       };
91718     } catch (std::exception& e) {
91719       {
91720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91721       };
91722     } catch (Dali::DaliException e) {
91723       {
91724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91725       };
91726     } catch (...) {
91727       {
91728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91729       };
91730     }
91731   }
91732
91733   jresult = (void *)result;
91734   return jresult;
91735 }
91736
91737
91738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91739   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91740
91741   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91742   {
91743     try {
91744       delete arg1;
91745     } catch (std::out_of_range& e) {
91746       {
91747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91748       };
91749     } catch (std::exception& e) {
91750       {
91751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91752       };
91753     } catch (Dali::DaliException e) {
91754       {
91755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91756       };
91757     } catch (...) {
91758       {
91759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91760       };
91761     }
91762   }
91763
91764 }
91765
91766
91767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91768   void * jresult ;
91769   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91770   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91771
91772   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91773   if (!arg1) {
91774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91775     return 0;
91776   }
91777   {
91778     try {
91779       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91780     } catch (std::out_of_range& e) {
91781       {
91782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91783       };
91784     } catch (std::exception& e) {
91785       {
91786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91787       };
91788     } catch (Dali::DaliException e) {
91789       {
91790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91791       };
91792     } catch (...) {
91793       {
91794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91795       };
91796     }
91797   }
91798
91799   jresult = (void *)result;
91800   return jresult;
91801 }
91802
91803
91804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91805   void * jresult ;
91806   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91807   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91808   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91809
91810   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91811   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91812   if (!arg2) {
91813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91814     return 0;
91815   }
91816   {
91817     try {
91818       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91819     } catch (std::out_of_range& e) {
91820       {
91821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91822       };
91823     } catch (std::exception& e) {
91824       {
91825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91826       };
91827     } catch (Dali::DaliException e) {
91828       {
91829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91830       };
91831     } catch (...) {
91832       {
91833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91834       };
91835     }
91836   }
91837
91838   jresult = (void *)result;
91839   return jresult;
91840 }
91841
91842
91843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91844   void * jresult ;
91845   Dali::Toolkit::AsyncImageLoader result;
91846
91847   {
91848     try {
91849       result = Dali::Toolkit::AsyncImageLoader::New();
91850     } catch (std::out_of_range& e) {
91851       {
91852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91853       };
91854     } catch (std::exception& e) {
91855       {
91856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91857       };
91858     } catch (Dali::DaliException e) {
91859       {
91860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91861       };
91862     } catch (...) {
91863       {
91864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91865       };
91866     }
91867   }
91868
91869   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91870   return jresult;
91871 }
91872
91873
91874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91875   void * jresult ;
91876   Dali::BaseHandle arg1 ;
91877   Dali::BaseHandle *argp1 ;
91878   Dali::Toolkit::AsyncImageLoader result;
91879
91880   argp1 = (Dali::BaseHandle *)jarg1;
91881   if (!argp1) {
91882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91883     return 0;
91884   }
91885   arg1 = *argp1;
91886   {
91887     try {
91888       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91889     } catch (std::out_of_range& e) {
91890       {
91891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91892       };
91893     } catch (std::exception& e) {
91894       {
91895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91896       };
91897     } catch (Dali::DaliException e) {
91898       {
91899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91900       };
91901     } catch (...) {
91902       {
91903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91904       };
91905     }
91906   }
91907
91908   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91909   return jresult;
91910 }
91911
91912
91913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91914   unsigned int jresult ;
91915   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91916   std::string *arg2 = 0 ;
91917   uint32_t result;
91918
91919   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91920   if (!jarg2) {
91921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91922     return 0;
91923   }
91924   std::string arg2_str(jarg2);
91925   arg2 = &arg2_str;
91926   {
91927     try {
91928       result = (arg1)->Load((std::string const &)*arg2);
91929     } catch (std::out_of_range& e) {
91930       {
91931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91932       };
91933     } catch (std::exception& e) {
91934       {
91935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91936       };
91937     } catch (Dali::DaliException e) {
91938       {
91939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91940       };
91941     } catch (...) {
91942       {
91943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91944       };
91945     }
91946   }
91947
91948   jresult = result;
91949
91950   //argout typemap for const std::string&
91951
91952   return jresult;
91953 }
91954
91955
91956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91957   unsigned int jresult ;
91958   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91959   std::string *arg2 = 0 ;
91960   Dali::ImageDimensions arg3 ;
91961   Dali::ImageDimensions *argp3 ;
91962   uint32_t result;
91963
91964   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91965   if (!jarg2) {
91966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91967     return 0;
91968   }
91969   std::string arg2_str(jarg2);
91970   arg2 = &arg2_str;
91971   argp3 = (Dali::ImageDimensions *)jarg3;
91972   if (!argp3) {
91973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91974     return 0;
91975   }
91976   arg3 = *argp3;
91977   {
91978     try {
91979       result = (arg1)->Load((std::string const &)*arg2,arg3);
91980     } catch (std::out_of_range& e) {
91981       {
91982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91983       };
91984     } catch (std::exception& e) {
91985       {
91986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91987       };
91988     } catch (Dali::DaliException e) {
91989       {
91990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91991       };
91992     } catch (...) {
91993       {
91994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91995       };
91996     }
91997   }
91998
91999   jresult = result;
92000
92001   //argout typemap for const std::string&
92002
92003   return jresult;
92004 }
92005
92006
92007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92008   unsigned int jresult ;
92009   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92010   std::string *arg2 = 0 ;
92011   Dali::ImageDimensions arg3 ;
92012   Dali::FittingMode::Type arg4 ;
92013   Dali::SamplingMode::Type arg5 ;
92014   bool arg6 ;
92015   Dali::ImageDimensions *argp3 ;
92016   uint32_t result;
92017
92018   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92019   if (!jarg2) {
92020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92021     return 0;
92022   }
92023   std::string arg2_str(jarg2);
92024   arg2 = &arg2_str;
92025   argp3 = (Dali::ImageDimensions *)jarg3;
92026   if (!argp3) {
92027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92028     return 0;
92029   }
92030   arg3 = *argp3;
92031   arg4 = (Dali::FittingMode::Type)jarg4;
92032   arg5 = (Dali::SamplingMode::Type)jarg5;
92033   arg6 = jarg6 ? true : false;
92034   {
92035     try {
92036       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92037     } catch (std::out_of_range& e) {
92038       {
92039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92040       };
92041     } catch (std::exception& e) {
92042       {
92043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92044       };
92045     } catch (Dali::DaliException e) {
92046       {
92047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92048       };
92049     } catch (...) {
92050       {
92051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92052       };
92053     }
92054   }
92055
92056   jresult = result;
92057
92058   //argout typemap for const std::string&
92059
92060   return jresult;
92061 }
92062
92063
92064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92065   unsigned int jresult ;
92066   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92067   uint32_t arg2 ;
92068   bool result;
92069
92070   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92071   arg2 = (uint32_t)jarg2;
92072   {
92073     try {
92074       result = (bool)(arg1)->Cancel(arg2);
92075     } catch (std::out_of_range& e) {
92076       {
92077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92078       };
92079     } catch (std::exception& e) {
92080       {
92081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92082       };
92083     } catch (Dali::DaliException e) {
92084       {
92085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92086       };
92087     } catch (...) {
92088       {
92089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92090       };
92091     }
92092   }
92093
92094   jresult = result;
92095   return jresult;
92096 }
92097
92098
92099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92100   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92101
92102   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92103   {
92104     try {
92105       (arg1)->CancelAll();
92106     } catch (std::out_of_range& e) {
92107       {
92108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92109       };
92110     } catch (std::exception& e) {
92111       {
92112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92113       };
92114     } catch (Dali::DaliException e) {
92115       {
92116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92117       };
92118     } catch (...) {
92119       {
92120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92121       };
92122     }
92123   }
92124
92125 }
92126
92127
92128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92129   void * jresult ;
92130   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92131   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92132
92133   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92134   {
92135     try {
92136       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92137     } catch (std::out_of_range& e) {
92138       {
92139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92140       };
92141     } catch (std::exception& e) {
92142       {
92143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92144       };
92145     } catch (Dali::DaliException e) {
92146       {
92147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92148       };
92149     } catch (...) {
92150       {
92151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92152       };
92153     }
92154   }
92155
92156   jresult = (void *)result;
92157   return jresult;
92158 }
92159
92160
92161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
92162   void * jresult ;
92163   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
92164   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92165
92166   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
92167   {
92168     try {
92169       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
92170     } catch (std::out_of_range& e) {
92171       {
92172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92173       };
92174     } catch (std::exception& e) {
92175       {
92176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92177       };
92178     } catch (Dali::DaliException e) {
92179       {
92180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92181       };
92182     } catch (...) {
92183       {
92184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92185       };
92186     }
92187   }
92188
92189   jresult = (void *)result;
92190   return jresult;
92191 }
92192
92193
92194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92195   void * jresult ;
92196   std::string *arg1 = 0 ;
92197   Dali::PixelData result;
92198
92199   if (!jarg1) {
92200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92201     return 0;
92202   }
92203   std::string arg1_str(jarg1);
92204   arg1 = &arg1_str;
92205   {
92206     try {
92207       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92208     } catch (std::out_of_range& e) {
92209       {
92210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92211       };
92212     } catch (std::exception& e) {
92213       {
92214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92215       };
92216     } catch (Dali::DaliException e) {
92217       {
92218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92219       };
92220     } catch (...) {
92221       {
92222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92223       };
92224     }
92225   }
92226
92227   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92228
92229   //argout typemap for const std::string&
92230
92231   return jresult;
92232 }
92233
92234
92235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92236   void * jresult ;
92237   std::string *arg1 = 0 ;
92238   Dali::ImageDimensions arg2 ;
92239   Dali::ImageDimensions *argp2 ;
92240   Dali::PixelData result;
92241
92242   if (!jarg1) {
92243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92244     return 0;
92245   }
92246   std::string arg1_str(jarg1);
92247   arg1 = &arg1_str;
92248   argp2 = (Dali::ImageDimensions *)jarg2;
92249   if (!argp2) {
92250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92251     return 0;
92252   }
92253   arg2 = *argp2;
92254   {
92255     try {
92256       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92257     } catch (std::out_of_range& e) {
92258       {
92259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92260       };
92261     } catch (std::exception& e) {
92262       {
92263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92264       };
92265     } catch (Dali::DaliException e) {
92266       {
92267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92268       };
92269     } catch (...) {
92270       {
92271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92272       };
92273     }
92274   }
92275
92276   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92277
92278   //argout typemap for const std::string&
92279
92280   return jresult;
92281 }
92282
92283
92284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92285   void * jresult ;
92286   std::string *arg1 = 0 ;
92287   Dali::ImageDimensions arg2 ;
92288   Dali::FittingMode::Type arg3 ;
92289   Dali::SamplingMode::Type arg4 ;
92290   bool arg5 ;
92291   Dali::ImageDimensions *argp2 ;
92292   Dali::PixelData result;
92293
92294   if (!jarg1) {
92295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92296     return 0;
92297   }
92298   std::string arg1_str(jarg1);
92299   arg1 = &arg1_str;
92300   argp2 = (Dali::ImageDimensions *)jarg2;
92301   if (!argp2) {
92302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92303     return 0;
92304   }
92305   arg2 = *argp2;
92306   arg3 = (Dali::FittingMode::Type)jarg3;
92307   arg4 = (Dali::SamplingMode::Type)jarg4;
92308   arg5 = jarg5 ? true : false;
92309   {
92310     try {
92311       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92312     } catch (std::out_of_range& e) {
92313       {
92314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92315       };
92316     } catch (std::exception& e) {
92317       {
92318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92319       };
92320     } catch (Dali::DaliException e) {
92321       {
92322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92323       };
92324     } catch (...) {
92325       {
92326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92327       };
92328     }
92329   }
92330
92331   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92332
92333   //argout typemap for const std::string&
92334
92335   return jresult;
92336 }
92337
92338
92339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92340   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92341
92342   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92343   {
92344     try {
92345       delete arg1;
92346     } catch (std::out_of_range& e) {
92347       {
92348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92349       };
92350     } catch (std::exception& e) {
92351       {
92352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92353       };
92354     } catch (Dali::DaliException e) {
92355       {
92356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92357       };
92358     } catch (...) {
92359       {
92360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92361       };
92362     }
92363   }
92364
92365 }
92366
92367
92368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92369   void * jresult ;
92370   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92371   Dali::Actor arg2 ;
92372   Dali::Actor arg3 ;
92373   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92374   Dali::Actor *argp2 ;
92375   Dali::Actor *argp3 ;
92376   Dali::Actor result;
92377
92378   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92379   argp2 = (Dali::Actor *)jarg2;
92380   if (!argp2) {
92381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92382     return 0;
92383   }
92384   arg2 = *argp2;
92385   argp3 = (Dali::Actor *)jarg3;
92386   if (!argp3) {
92387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92388     return 0;
92389   }
92390   arg3 = *argp3;
92391   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92392   {
92393     try {
92394       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92395     } catch (std::out_of_range& e) {
92396       {
92397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92398       };
92399     } catch (std::exception& e) {
92400       {
92401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92402       };
92403     } catch (Dali::DaliException e) {
92404       {
92405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92406       };
92407     } catch (...) {
92408       {
92409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92410       };
92411     }
92412   }
92413
92414   jresult = new Dali::Actor((const Dali::Actor &)result);
92415   return jresult;
92416 }
92417
92418
92419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92420   void * jresult ;
92421   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92422
92423   {
92424     try {
92425       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92426     } catch (std::out_of_range& e) {
92427       {
92428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92429       };
92430     } catch (std::exception& e) {
92431       {
92432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92433       };
92434     } catch (Dali::DaliException e) {
92435       {
92436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92437       };
92438     } catch (...) {
92439       {
92440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92441       };
92442     }
92443   }
92444
92445   jresult = (void *)result;
92446   return jresult;
92447 }
92448
92449
92450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92451   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92452   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92453   if (director) {
92454     director->swig_connect_director(callback0);
92455   }
92456 }
92457
92458
92459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92460   KeyboardFocusManager arg1 ;
92461   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92462   KeyboardFocusManager *argp1 ;
92463
92464   argp1 = (KeyboardFocusManager *)jarg1;
92465   if (!argp1) {
92466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92467     return ;
92468   }
92469   arg1 = *argp1;
92470   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92471   if (!arg2) {
92472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92473     return ;
92474   }
92475   {
92476     try {
92477       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92478     } catch (std::out_of_range& e) {
92479       {
92480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92481       };
92482     } catch (std::exception& e) {
92483       {
92484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92485       };
92486     } catch (Dali::DaliException e) {
92487       {
92488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92489       };
92490     } catch (...) {
92491       {
92492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92493       };
92494     }
92495   }
92496
92497 }
92498
92499
92500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92501   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92502
92503   arg1 = (std::vector< unsigned int > *)jarg1;
92504   {
92505     try {
92506       (arg1)->clear();
92507     } catch (std::out_of_range& e) {
92508       {
92509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92510       };
92511     } catch (std::exception& e) {
92512       {
92513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92514       };
92515     } catch (Dali::DaliException e) {
92516       {
92517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92518       };
92519     } catch (...) {
92520       {
92521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92522       };
92523     }
92524   }
92525
92526 }
92527
92528
92529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92530   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92531   unsigned int *arg2 = 0 ;
92532   unsigned int temp2 ;
92533
92534   arg1 = (std::vector< unsigned int > *)jarg1;
92535   temp2 = (unsigned int)jarg2;
92536   arg2 = &temp2;
92537   {
92538     try {
92539       (arg1)->push_back((unsigned int const &)*arg2);
92540     } catch (std::out_of_range& e) {
92541       {
92542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92543       };
92544     } catch (std::exception& e) {
92545       {
92546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92547       };
92548     } catch (Dali::DaliException e) {
92549       {
92550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92551       };
92552     } catch (...) {
92553       {
92554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92555       };
92556     }
92557   }
92558
92559 }
92560
92561
92562 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92563   unsigned long jresult ;
92564   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92565   std::vector< unsigned int >::size_type result;
92566
92567   arg1 = (std::vector< unsigned int > *)jarg1;
92568   {
92569     try {
92570       result = ((std::vector< unsigned int > const *)arg1)->size();
92571     } catch (std::out_of_range& e) {
92572       {
92573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92574       };
92575     } catch (std::exception& e) {
92576       {
92577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92578       };
92579     } catch (Dali::DaliException e) {
92580       {
92581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92582       };
92583     } catch (...) {
92584       {
92585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92586       };
92587     }
92588   }
92589
92590   jresult = (unsigned long)result;
92591   return jresult;
92592 }
92593
92594
92595 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92596   unsigned long jresult ;
92597   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92598   std::vector< unsigned int >::size_type result;
92599
92600   arg1 = (std::vector< unsigned int > *)jarg1;
92601   {
92602     try {
92603       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92604     } catch (std::out_of_range& e) {
92605       {
92606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92607       };
92608     } catch (std::exception& e) {
92609       {
92610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92611       };
92612     } catch (Dali::DaliException e) {
92613       {
92614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92615       };
92616     } catch (...) {
92617       {
92618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92619       };
92620     }
92621   }
92622
92623   jresult = (unsigned long)result;
92624   return jresult;
92625 }
92626
92627
92628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92629   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92630   std::vector< unsigned int >::size_type arg2 ;
92631
92632   arg1 = (std::vector< unsigned int > *)jarg1;
92633   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92634   {
92635     try {
92636       (arg1)->reserve(arg2);
92637     } catch (std::out_of_range& e) {
92638       {
92639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92640       };
92641     } catch (std::exception& e) {
92642       {
92643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92644       };
92645     } catch (Dali::DaliException e) {
92646       {
92647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92648       };
92649     } catch (...) {
92650       {
92651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92652       };
92653     }
92654   }
92655
92656 }
92657
92658
92659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92660   void * jresult ;
92661   std::vector< unsigned int > *result = 0 ;
92662
92663   {
92664     try {
92665       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92666     } catch (std::out_of_range& e) {
92667       {
92668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92669       };
92670     } catch (std::exception& e) {
92671       {
92672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92673       };
92674     } catch (Dali::DaliException e) {
92675       {
92676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92677       };
92678     } catch (...) {
92679       {
92680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92681       };
92682     }
92683   }
92684
92685   jresult = (void *)result;
92686   return jresult;
92687 }
92688
92689
92690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92691   void * jresult ;
92692   std::vector< unsigned int > *arg1 = 0 ;
92693   std::vector< unsigned int > *result = 0 ;
92694
92695   arg1 = (std::vector< unsigned int > *)jarg1;
92696   if (!arg1) {
92697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92698     return 0;
92699   }
92700   {
92701     try {
92702       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92703     } catch (std::out_of_range& e) {
92704       {
92705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92706       };
92707     } catch (std::exception& e) {
92708       {
92709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92710       };
92711     } catch (Dali::DaliException e) {
92712       {
92713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92714       };
92715     } catch (...) {
92716       {
92717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92718       };
92719     }
92720   }
92721
92722   jresult = (void *)result;
92723   return jresult;
92724 }
92725
92726
92727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92728   void * jresult ;
92729   int arg1 ;
92730   std::vector< unsigned int > *result = 0 ;
92731
92732   arg1 = (int)jarg1;
92733   {
92734     try {
92735       try {
92736         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92737       }
92738       catch(std::out_of_range &_e) {
92739         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92740         return 0;
92741       }
92742
92743     } catch (std::out_of_range& e) {
92744       {
92745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92746       };
92747     } catch (std::exception& e) {
92748       {
92749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92750       };
92751     } catch (Dali::DaliException e) {
92752       {
92753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92754       };
92755     } catch (...) {
92756       {
92757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92758       };
92759     }
92760   }
92761
92762   jresult = (void *)result;
92763   return jresult;
92764 }
92765
92766
92767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92768   unsigned int jresult ;
92769   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92770   int arg2 ;
92771   unsigned int result;
92772
92773   arg1 = (std::vector< unsigned int > *)jarg1;
92774   arg2 = (int)jarg2;
92775   {
92776     try {
92777       try {
92778         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92779       }
92780       catch(std::out_of_range &_e) {
92781         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92782         return 0;
92783       }
92784
92785     } catch (std::out_of_range& e) {
92786       {
92787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92788       };
92789     } catch (std::exception& e) {
92790       {
92791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92792       };
92793     } catch (Dali::DaliException e) {
92794       {
92795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92796       };
92797     } catch (...) {
92798       {
92799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92800       };
92801     }
92802   }
92803
92804   jresult = result;
92805   return jresult;
92806 }
92807
92808
92809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92810   unsigned int jresult ;
92811   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92812   int arg2 ;
92813   unsigned int *result = 0 ;
92814
92815   arg1 = (std::vector< unsigned int > *)jarg1;
92816   arg2 = (int)jarg2;
92817   {
92818     try {
92819       try {
92820         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92821       }
92822       catch(std::out_of_range &_e) {
92823         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92824         return 0;
92825       }
92826
92827     } catch (std::out_of_range& e) {
92828       {
92829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92830       };
92831     } catch (std::exception& e) {
92832       {
92833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92834       };
92835     } catch (Dali::DaliException e) {
92836       {
92837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92838       };
92839     } catch (...) {
92840       {
92841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92842       };
92843     }
92844   }
92845
92846   jresult = *result;
92847   return jresult;
92848 }
92849
92850
92851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92852   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92853   int arg2 ;
92854   unsigned int *arg3 = 0 ;
92855   unsigned int temp3 ;
92856
92857   arg1 = (std::vector< unsigned int > *)jarg1;
92858   arg2 = (int)jarg2;
92859   temp3 = (unsigned int)jarg3;
92860   arg3 = &temp3;
92861   {
92862     try {
92863       try {
92864         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92865       }
92866       catch(std::out_of_range &_e) {
92867         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92868         return ;
92869       }
92870
92871     } catch (std::out_of_range& e) {
92872       {
92873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92874       };
92875     } catch (std::exception& e) {
92876       {
92877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92878       };
92879     } catch (Dali::DaliException e) {
92880       {
92881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92882       };
92883     } catch (...) {
92884       {
92885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92886       };
92887     }
92888   }
92889
92890 }
92891
92892
92893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92894   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92895   std::vector< unsigned int > *arg2 = 0 ;
92896
92897   arg1 = (std::vector< unsigned int > *)jarg1;
92898   arg2 = (std::vector< unsigned int > *)jarg2;
92899   if (!arg2) {
92900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92901     return ;
92902   }
92903   {
92904     try {
92905       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92906     } catch (std::out_of_range& e) {
92907       {
92908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92909       };
92910     } catch (std::exception& e) {
92911       {
92912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92913       };
92914     } catch (Dali::DaliException e) {
92915       {
92916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92917       };
92918     } catch (...) {
92919       {
92920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92921       };
92922     }
92923   }
92924
92925 }
92926
92927
92928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92929   void * jresult ;
92930   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92931   int arg2 ;
92932   int arg3 ;
92933   std::vector< unsigned int > *result = 0 ;
92934
92935   arg1 = (std::vector< unsigned int > *)jarg1;
92936   arg2 = (int)jarg2;
92937   arg3 = (int)jarg3;
92938   {
92939     try {
92940       try {
92941         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92942       }
92943       catch(std::out_of_range &_e) {
92944         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92945         return 0;
92946       }
92947       catch(std::invalid_argument &_e) {
92948         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92949         return 0;
92950       }
92951
92952     } catch (std::out_of_range& e) {
92953       {
92954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92955       };
92956     } catch (std::exception& e) {
92957       {
92958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92959       };
92960     } catch (Dali::DaliException e) {
92961       {
92962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92963       };
92964     } catch (...) {
92965       {
92966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92967       };
92968     }
92969   }
92970
92971   jresult = (void *)result;
92972   return jresult;
92973 }
92974
92975
92976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92977   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92978   int arg2 ;
92979   unsigned int *arg3 = 0 ;
92980   unsigned int temp3 ;
92981
92982   arg1 = (std::vector< unsigned int > *)jarg1;
92983   arg2 = (int)jarg2;
92984   temp3 = (unsigned int)jarg3;
92985   arg3 = &temp3;
92986   {
92987     try {
92988       try {
92989         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92990       }
92991       catch(std::out_of_range &_e) {
92992         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92993         return ;
92994       }
92995
92996     } catch (std::out_of_range& e) {
92997       {
92998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92999       };
93000     } catch (std::exception& e) {
93001       {
93002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93003       };
93004     } catch (Dali::DaliException e) {
93005       {
93006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93007       };
93008     } catch (...) {
93009       {
93010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93011       };
93012     }
93013   }
93014
93015 }
93016
93017
93018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93019   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93020   int arg2 ;
93021   std::vector< unsigned int > *arg3 = 0 ;
93022
93023   arg1 = (std::vector< unsigned int > *)jarg1;
93024   arg2 = (int)jarg2;
93025   arg3 = (std::vector< unsigned int > *)jarg3;
93026   if (!arg3) {
93027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93028     return ;
93029   }
93030   {
93031     try {
93032       try {
93033         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93034       }
93035       catch(std::out_of_range &_e) {
93036         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93037         return ;
93038       }
93039
93040     } catch (std::out_of_range& e) {
93041       {
93042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93043       };
93044     } catch (std::exception& e) {
93045       {
93046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93047       };
93048     } catch (Dali::DaliException e) {
93049       {
93050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93051       };
93052     } catch (...) {
93053       {
93054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93055       };
93056     }
93057   }
93058
93059 }
93060
93061
93062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93063   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93064   int arg2 ;
93065
93066   arg1 = (std::vector< unsigned int > *)jarg1;
93067   arg2 = (int)jarg2;
93068   {
93069     try {
93070       try {
93071         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93072       }
93073       catch(std::out_of_range &_e) {
93074         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93075         return ;
93076       }
93077
93078     } catch (std::out_of_range& e) {
93079       {
93080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93081       };
93082     } catch (std::exception& e) {
93083       {
93084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93085       };
93086     } catch (Dali::DaliException e) {
93087       {
93088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93089       };
93090     } catch (...) {
93091       {
93092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93093       };
93094     }
93095   }
93096
93097 }
93098
93099
93100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93101   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93102   int arg2 ;
93103   int arg3 ;
93104
93105   arg1 = (std::vector< unsigned int > *)jarg1;
93106   arg2 = (int)jarg2;
93107   arg3 = (int)jarg3;
93108   {
93109     try {
93110       try {
93111         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93112       }
93113       catch(std::out_of_range &_e) {
93114         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93115         return ;
93116       }
93117       catch(std::invalid_argument &_e) {
93118         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93119         return ;
93120       }
93121
93122     } catch (std::out_of_range& e) {
93123       {
93124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93125       };
93126     } catch (std::exception& e) {
93127       {
93128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93129       };
93130     } catch (Dali::DaliException e) {
93131       {
93132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93133       };
93134     } catch (...) {
93135       {
93136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93137       };
93138     }
93139   }
93140
93141 }
93142
93143
93144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93145   void * jresult ;
93146   unsigned int *arg1 = 0 ;
93147   int arg2 ;
93148   unsigned int temp1 ;
93149   std::vector< unsigned int > *result = 0 ;
93150
93151   temp1 = (unsigned int)jarg1;
93152   arg1 = &temp1;
93153   arg2 = (int)jarg2;
93154   {
93155     try {
93156       try {
93157         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93158       }
93159       catch(std::out_of_range &_e) {
93160         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93161         return 0;
93162       }
93163
93164     } catch (std::out_of_range& e) {
93165       {
93166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93167       };
93168     } catch (std::exception& e) {
93169       {
93170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93171       };
93172     } catch (Dali::DaliException e) {
93173       {
93174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93175       };
93176     } catch (...) {
93177       {
93178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93179       };
93180     }
93181   }
93182
93183   jresult = (void *)result;
93184   return jresult;
93185 }
93186
93187
93188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93189   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93190
93191   arg1 = (std::vector< unsigned int > *)jarg1;
93192   {
93193     try {
93194       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93195     } catch (std::out_of_range& e) {
93196       {
93197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93198       };
93199     } catch (std::exception& e) {
93200       {
93201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93202       };
93203     } catch (Dali::DaliException e) {
93204       {
93205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93206       };
93207     } catch (...) {
93208       {
93209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93210       };
93211     }
93212   }
93213
93214 }
93215
93216
93217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93218   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93219   int arg2 ;
93220   int arg3 ;
93221
93222   arg1 = (std::vector< unsigned int > *)jarg1;
93223   arg2 = (int)jarg2;
93224   arg3 = (int)jarg3;
93225   {
93226     try {
93227       try {
93228         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93229       }
93230       catch(std::out_of_range &_e) {
93231         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93232         return ;
93233       }
93234       catch(std::invalid_argument &_e) {
93235         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93236         return ;
93237       }
93238
93239     } catch (std::out_of_range& e) {
93240       {
93241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93242       };
93243     } catch (std::exception& e) {
93244       {
93245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93246       };
93247     } catch (Dali::DaliException e) {
93248       {
93249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93250       };
93251     } catch (...) {
93252       {
93253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93254       };
93255     }
93256   }
93257
93258 }
93259
93260
93261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93262   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93263   int arg2 ;
93264   std::vector< unsigned int > *arg3 = 0 ;
93265
93266   arg1 = (std::vector< unsigned int > *)jarg1;
93267   arg2 = (int)jarg2;
93268   arg3 = (std::vector< unsigned int > *)jarg3;
93269   if (!arg3) {
93270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93271     return ;
93272   }
93273   {
93274     try {
93275       try {
93276         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93277       }
93278       catch(std::out_of_range &_e) {
93279         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93280         return ;
93281       }
93282
93283     } catch (std::out_of_range& e) {
93284       {
93285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93286       };
93287     } catch (std::exception& e) {
93288       {
93289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93290       };
93291     } catch (Dali::DaliException e) {
93292       {
93293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93294       };
93295     } catch (...) {
93296       {
93297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93298       };
93299     }
93300   }
93301
93302 }
93303
93304
93305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93306   unsigned int jresult ;
93307   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93308   unsigned int *arg2 = 0 ;
93309   unsigned int temp2 ;
93310   bool result;
93311
93312   arg1 = (std::vector< unsigned int > *)jarg1;
93313   temp2 = (unsigned int)jarg2;
93314   arg2 = &temp2;
93315   {
93316     try {
93317       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93318     } catch (std::out_of_range& e) {
93319       {
93320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93321       };
93322     } catch (std::exception& e) {
93323       {
93324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93325       };
93326     } catch (Dali::DaliException e) {
93327       {
93328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93329       };
93330     } catch (...) {
93331       {
93332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93333       };
93334     }
93335   }
93336
93337   jresult = result;
93338   return jresult;
93339 }
93340
93341
93342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93343   int jresult ;
93344   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93345   unsigned int *arg2 = 0 ;
93346   unsigned int temp2 ;
93347   int result;
93348
93349   arg1 = (std::vector< unsigned int > *)jarg1;
93350   temp2 = (unsigned int)jarg2;
93351   arg2 = &temp2;
93352   {
93353     try {
93354       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93355     } catch (std::out_of_range& e) {
93356       {
93357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93358       };
93359     } catch (std::exception& e) {
93360       {
93361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93362       };
93363     } catch (Dali::DaliException e) {
93364       {
93365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93366       };
93367     } catch (...) {
93368       {
93369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93370       };
93371     }
93372   }
93373
93374   jresult = result;
93375   return jresult;
93376 }
93377
93378
93379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93380   int jresult ;
93381   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93382   unsigned int *arg2 = 0 ;
93383   unsigned int temp2 ;
93384   int result;
93385
93386   arg1 = (std::vector< unsigned int > *)jarg1;
93387   temp2 = (unsigned int)jarg2;
93388   arg2 = &temp2;
93389   {
93390     try {
93391       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93392     } catch (std::out_of_range& e) {
93393       {
93394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93395       };
93396     } catch (std::exception& e) {
93397       {
93398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93399       };
93400     } catch (Dali::DaliException e) {
93401       {
93402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93403       };
93404     } catch (...) {
93405       {
93406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93407       };
93408     }
93409   }
93410
93411   jresult = result;
93412   return jresult;
93413 }
93414
93415
93416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93417   unsigned int jresult ;
93418   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93419   unsigned int *arg2 = 0 ;
93420   unsigned int temp2 ;
93421   bool result;
93422
93423   arg1 = (std::vector< unsigned int > *)jarg1;
93424   temp2 = (unsigned int)jarg2;
93425   arg2 = &temp2;
93426   {
93427     try {
93428       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93429     } catch (std::out_of_range& e) {
93430       {
93431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93432       };
93433     } catch (std::exception& e) {
93434       {
93435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93436       };
93437     } catch (Dali::DaliException e) {
93438       {
93439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93440       };
93441     } catch (...) {
93442       {
93443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93444       };
93445     }
93446   }
93447
93448   jresult = result;
93449   return jresult;
93450 }
93451
93452
93453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93454   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93455
93456   arg1 = (std::vector< unsigned int > *)jarg1;
93457   {
93458     try {
93459       delete arg1;
93460     } catch (std::out_of_range& e) {
93461       {
93462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93463       };
93464     } catch (std::exception& e) {
93465       {
93466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93467       };
93468     } catch (Dali::DaliException e) {
93469       {
93470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93471       };
93472     } catch (...) {
93473       {
93474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93475       };
93476     }
93477   }
93478
93479 }
93480
93481
93482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93483   void * jresult ;
93484   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93485
93486   {
93487     try {
93488       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93489     } catch (std::out_of_range& e) {
93490       {
93491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93492       };
93493     } catch (std::exception& e) {
93494       {
93495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93496       };
93497     } catch (Dali::DaliException e) {
93498       {
93499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93500       };
93501     } catch (...) {
93502       {
93503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93504       };
93505     }
93506   }
93507
93508   jresult = (void *)result;
93509   return jresult;
93510 }
93511
93512
93513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93514   void * jresult ;
93515   unsigned int arg1 ;
93516   Dali::Actor arg2 ;
93517   Dali::Actor *argp2 ;
93518   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93519
93520   arg1 = (unsigned int)jarg1;
93521   argp2 = (Dali::Actor *)jarg2;
93522   if (!argp2) {
93523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93524     return 0;
93525   }
93526   arg2 = *argp2;
93527   {
93528     try {
93529       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93530     } catch (std::out_of_range& e) {
93531       {
93532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93533       };
93534     } catch (std::exception& e) {
93535       {
93536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93537       };
93538     } catch (Dali::DaliException e) {
93539       {
93540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93541       };
93542     } catch (...) {
93543       {
93544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93545       };
93546     }
93547   }
93548
93549   jresult = (void *)result;
93550   return jresult;
93551 }
93552
93553
93554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93555   void * jresult ;
93556   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93557   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93558
93559   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93560   if (!arg1) {
93561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93562     return 0;
93563   }
93564   {
93565     try {
93566       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93567     } catch (std::out_of_range& e) {
93568       {
93569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93570       };
93571     } catch (std::exception& e) {
93572       {
93573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93574       };
93575     } catch (Dali::DaliException e) {
93576       {
93577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93578       };
93579     } catch (...) {
93580       {
93581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93582       };
93583     }
93584   }
93585
93586   jresult = (void *)result;
93587   return jresult;
93588 }
93589
93590
93591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93592   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93593   unsigned int arg2 ;
93594
93595   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93596   arg2 = (unsigned int)jarg2;
93597   if (arg1) (arg1)->first = arg2;
93598 }
93599
93600
93601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93602   unsigned int jresult ;
93603   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93604   unsigned int result;
93605
93606   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93607   result = (unsigned int) ((arg1)->first);
93608   jresult = result;
93609   return jresult;
93610 }
93611
93612
93613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93614   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93615   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93616
93617   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93618   arg2 = (Dali::Actor *)jarg2;
93619   if (arg1) (arg1)->second = *arg2;
93620 }
93621
93622
93623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93624   void * jresult ;
93625   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93626   Dali::Actor *result = 0 ;
93627
93628   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93629   result = (Dali::Actor *)& ((arg1)->second);
93630   jresult = (void *)result;
93631   return jresult;
93632 }
93633
93634
93635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93636   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93637
93638   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93639   {
93640     try {
93641       delete arg1;
93642     } catch (std::out_of_range& e) {
93643       {
93644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93645       };
93646     } catch (std::exception& e) {
93647       {
93648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93649       };
93650     } catch (Dali::DaliException e) {
93651       {
93652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93653       };
93654     } catch (...) {
93655       {
93656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93657       };
93658     }
93659   }
93660
93661 }
93662
93663
93664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93665   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93666
93667   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93668   {
93669     try {
93670       (arg1)->clear();
93671     } catch (std::out_of_range& e) {
93672       {
93673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93674       };
93675     } catch (std::exception& e) {
93676       {
93677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93678       };
93679     } catch (Dali::DaliException e) {
93680       {
93681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93682       };
93683     } catch (...) {
93684       {
93685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93686       };
93687     }
93688   }
93689
93690 }
93691
93692
93693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93694   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93695   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93696
93697   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93698   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93699   if (!arg2) {
93700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93701     return ;
93702   }
93703   {
93704     try {
93705       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93706     } catch (std::out_of_range& e) {
93707       {
93708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93709       };
93710     } catch (std::exception& e) {
93711       {
93712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93713       };
93714     } catch (Dali::DaliException e) {
93715       {
93716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93717       };
93718     } catch (...) {
93719       {
93720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93721       };
93722     }
93723   }
93724
93725 }
93726
93727
93728 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93729   unsigned long jresult ;
93730   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93731   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93732
93733   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93734   {
93735     try {
93736       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93737     } catch (std::out_of_range& e) {
93738       {
93739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93740       };
93741     } catch (std::exception& e) {
93742       {
93743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93744       };
93745     } catch (Dali::DaliException e) {
93746       {
93747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93748       };
93749     } catch (...) {
93750       {
93751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93752       };
93753     }
93754   }
93755
93756   jresult = (unsigned long)result;
93757   return jresult;
93758 }
93759
93760
93761 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93762   unsigned long jresult ;
93763   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93764   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93765
93766   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93767   {
93768     try {
93769       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93770     } catch (std::out_of_range& e) {
93771       {
93772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93773       };
93774     } catch (std::exception& e) {
93775       {
93776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93777       };
93778     } catch (Dali::DaliException e) {
93779       {
93780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93781       };
93782     } catch (...) {
93783       {
93784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93785       };
93786     }
93787   }
93788
93789   jresult = (unsigned long)result;
93790   return jresult;
93791 }
93792
93793
93794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93795   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93796   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93797
93798   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93799   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93800   {
93801     try {
93802       (arg1)->reserve(arg2);
93803     } catch (std::out_of_range& e) {
93804       {
93805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93806       };
93807     } catch (std::exception& e) {
93808       {
93809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93810       };
93811     } catch (Dali::DaliException e) {
93812       {
93813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93814       };
93815     } catch (...) {
93816       {
93817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93818       };
93819     }
93820   }
93821
93822 }
93823
93824
93825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93826   void * jresult ;
93827   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93828
93829   {
93830     try {
93831       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93832     } catch (std::out_of_range& e) {
93833       {
93834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93835       };
93836     } catch (std::exception& e) {
93837       {
93838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93839       };
93840     } catch (Dali::DaliException e) {
93841       {
93842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93843       };
93844     } catch (...) {
93845       {
93846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93847       };
93848     }
93849   }
93850
93851   jresult = (void *)result;
93852   return jresult;
93853 }
93854
93855
93856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93857   void * jresult ;
93858   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93859   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93860
93861   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93862   if (!arg1) {
93863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93864     return 0;
93865   }
93866   {
93867     try {
93868       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);
93869     } catch (std::out_of_range& e) {
93870       {
93871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93872       };
93873     } catch (std::exception& e) {
93874       {
93875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93876       };
93877     } catch (Dali::DaliException e) {
93878       {
93879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93880       };
93881     } catch (...) {
93882       {
93883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93884       };
93885     }
93886   }
93887
93888   jresult = (void *)result;
93889   return jresult;
93890 }
93891
93892
93893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93894   void * jresult ;
93895   int arg1 ;
93896   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93897
93898   arg1 = (int)jarg1;
93899   {
93900     try {
93901       try {
93902         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);
93903       }
93904       catch(std::out_of_range &_e) {
93905         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93906         return 0;
93907       }
93908
93909     } catch (std::out_of_range& e) {
93910       {
93911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93912       };
93913     } catch (std::exception& e) {
93914       {
93915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93916       };
93917     } catch (Dali::DaliException e) {
93918       {
93919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93920       };
93921     } catch (...) {
93922       {
93923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93924       };
93925     }
93926   }
93927
93928   jresult = (void *)result;
93929   return jresult;
93930 }
93931
93932
93933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93934   void * jresult ;
93935   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93936   int arg2 ;
93937   std::pair< unsigned int,Dali::Actor > result;
93938
93939   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93940   arg2 = (int)jarg2;
93941   {
93942     try {
93943       try {
93944         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93945       }
93946       catch(std::out_of_range &_e) {
93947         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93948         return 0;
93949       }
93950
93951     } catch (std::out_of_range& e) {
93952       {
93953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93954       };
93955     } catch (std::exception& e) {
93956       {
93957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93958       };
93959     } catch (Dali::DaliException e) {
93960       {
93961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93962       };
93963     } catch (...) {
93964       {
93965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93966       };
93967     }
93968   }
93969
93970   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93971   return jresult;
93972 }
93973
93974
93975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93976   void * jresult ;
93977   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93978   int arg2 ;
93979   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93980
93981   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93982   arg2 = (int)jarg2;
93983   {
93984     try {
93985       try {
93986         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93987       }
93988       catch(std::out_of_range &_e) {
93989         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93990         return 0;
93991       }
93992
93993     } catch (std::out_of_range& e) {
93994       {
93995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93996       };
93997     } catch (std::exception& e) {
93998       {
93999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94000       };
94001     } catch (Dali::DaliException e) {
94002       {
94003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94004       };
94005     } catch (...) {
94006       {
94007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94008       };
94009     }
94010   }
94011
94012   jresult = (void *)result;
94013   return jresult;
94014 }
94015
94016
94017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94018   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94019   int arg2 ;
94020   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94021
94022   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94023   arg2 = (int)jarg2;
94024   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94025   if (!arg3) {
94026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94027     return ;
94028   }
94029   {
94030     try {
94031       try {
94032         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);
94033       }
94034       catch(std::out_of_range &_e) {
94035         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94036         return ;
94037       }
94038
94039     } catch (std::out_of_range& e) {
94040       {
94041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94042       };
94043     } catch (std::exception& e) {
94044       {
94045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94046       };
94047     } catch (Dali::DaliException e) {
94048       {
94049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94050       };
94051     } catch (...) {
94052       {
94053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94054       };
94055     }
94056   }
94057
94058 }
94059
94060
94061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94062   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94063   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94064
94065   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94066   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94067   if (!arg2) {
94068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94069     return ;
94070   }
94071   {
94072     try {
94073       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);
94074     } catch (std::out_of_range& e) {
94075       {
94076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94077       };
94078     } catch (std::exception& e) {
94079       {
94080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94081       };
94082     } catch (Dali::DaliException e) {
94083       {
94084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94085       };
94086     } catch (...) {
94087       {
94088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94089       };
94090     }
94091   }
94092
94093 }
94094
94095
94096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94097   void * jresult ;
94098   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94099   int arg2 ;
94100   int arg3 ;
94101   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94102
94103   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94104   arg2 = (int)jarg2;
94105   arg3 = (int)jarg3;
94106   {
94107     try {
94108       try {
94109         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);
94110       }
94111       catch(std::out_of_range &_e) {
94112         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94113         return 0;
94114       }
94115       catch(std::invalid_argument &_e) {
94116         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94117         return 0;
94118       }
94119
94120     } catch (std::out_of_range& e) {
94121       {
94122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94123       };
94124     } catch (std::exception& e) {
94125       {
94126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94127       };
94128     } catch (Dali::DaliException e) {
94129       {
94130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94131       };
94132     } catch (...) {
94133       {
94134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94135       };
94136     }
94137   }
94138
94139   jresult = (void *)result;
94140   return jresult;
94141 }
94142
94143
94144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94145   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94146   int arg2 ;
94147   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94148
94149   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94150   arg2 = (int)jarg2;
94151   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94152   if (!arg3) {
94153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94154     return ;
94155   }
94156   {
94157     try {
94158       try {
94159         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);
94160       }
94161       catch(std::out_of_range &_e) {
94162         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94163         return ;
94164       }
94165
94166     } catch (std::out_of_range& e) {
94167       {
94168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94169       };
94170     } catch (std::exception& e) {
94171       {
94172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94173       };
94174     } catch (Dali::DaliException e) {
94175       {
94176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94177       };
94178     } catch (...) {
94179       {
94180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94181       };
94182     }
94183   }
94184
94185 }
94186
94187
94188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94189   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94190   int arg2 ;
94191   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94192
94193   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94194   arg2 = (int)jarg2;
94195   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94196   if (!arg3) {
94197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94198     return ;
94199   }
94200   {
94201     try {
94202       try {
94203         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);
94204       }
94205       catch(std::out_of_range &_e) {
94206         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94207         return ;
94208       }
94209
94210     } catch (std::out_of_range& e) {
94211       {
94212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94213       };
94214     } catch (std::exception& e) {
94215       {
94216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94217       };
94218     } catch (Dali::DaliException e) {
94219       {
94220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94221       };
94222     } catch (...) {
94223       {
94224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94225       };
94226     }
94227   }
94228
94229 }
94230
94231
94232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94233   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94234   int arg2 ;
94235
94236   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94237   arg2 = (int)jarg2;
94238   {
94239     try {
94240       try {
94241         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94242       }
94243       catch(std::out_of_range &_e) {
94244         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94245         return ;
94246       }
94247
94248     } catch (std::out_of_range& e) {
94249       {
94250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94251       };
94252     } catch (std::exception& e) {
94253       {
94254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94255       };
94256     } catch (Dali::DaliException e) {
94257       {
94258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94259       };
94260     } catch (...) {
94261       {
94262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94263       };
94264     }
94265   }
94266
94267 }
94268
94269
94270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94271   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94272   int arg2 ;
94273   int arg3 ;
94274
94275   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94276   arg2 = (int)jarg2;
94277   arg3 = (int)jarg3;
94278   {
94279     try {
94280       try {
94281         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94282       }
94283       catch(std::out_of_range &_e) {
94284         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94285         return ;
94286       }
94287       catch(std::invalid_argument &_e) {
94288         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94289         return ;
94290       }
94291
94292     } catch (std::out_of_range& e) {
94293       {
94294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94295       };
94296     } catch (std::exception& e) {
94297       {
94298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94299       };
94300     } catch (Dali::DaliException e) {
94301       {
94302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94303       };
94304     } catch (...) {
94305       {
94306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94307       };
94308     }
94309   }
94310
94311 }
94312
94313
94314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94315   void * jresult ;
94316   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94317   int arg2 ;
94318   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94319
94320   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94321   if (!arg1) {
94322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94323     return 0;
94324   }
94325   arg2 = (int)jarg2;
94326   {
94327     try {
94328       try {
94329         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);
94330       }
94331       catch(std::out_of_range &_e) {
94332         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94333         return 0;
94334       }
94335
94336     } catch (std::out_of_range& e) {
94337       {
94338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94339       };
94340     } catch (std::exception& e) {
94341       {
94342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94343       };
94344     } catch (Dali::DaliException e) {
94345       {
94346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94347       };
94348     } catch (...) {
94349       {
94350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94351       };
94352     }
94353   }
94354
94355   jresult = (void *)result;
94356   return jresult;
94357 }
94358
94359
94360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94361   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94362
94363   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94364   {
94365     try {
94366       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94367     } catch (std::out_of_range& e) {
94368       {
94369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94370       };
94371     } catch (std::exception& e) {
94372       {
94373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94374       };
94375     } catch (Dali::DaliException e) {
94376       {
94377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94378       };
94379     } catch (...) {
94380       {
94381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94382       };
94383     }
94384   }
94385
94386 }
94387
94388
94389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94390   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94391   int arg2 ;
94392   int arg3 ;
94393
94394   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94395   arg2 = (int)jarg2;
94396   arg3 = (int)jarg3;
94397   {
94398     try {
94399       try {
94400         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94401       }
94402       catch(std::out_of_range &_e) {
94403         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94404         return ;
94405       }
94406       catch(std::invalid_argument &_e) {
94407         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94408         return ;
94409       }
94410
94411     } catch (std::out_of_range& e) {
94412       {
94413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94414       };
94415     } catch (std::exception& e) {
94416       {
94417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94418       };
94419     } catch (Dali::DaliException e) {
94420       {
94421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94422       };
94423     } catch (...) {
94424       {
94425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94426       };
94427     }
94428   }
94429
94430 }
94431
94432
94433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94434   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94435   int arg2 ;
94436   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94437
94438   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94439   arg2 = (int)jarg2;
94440   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94441   if (!arg3) {
94442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94443     return ;
94444   }
94445   {
94446     try {
94447       try {
94448         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__SetRange(arg1,arg2,(std::vector< std::pair< unsigned int,Dali::Actor > > const &)*arg3);
94449       }
94450       catch(std::out_of_range &_e) {
94451         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94452         return ;
94453       }
94454
94455     } catch (std::out_of_range& e) {
94456       {
94457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94458       };
94459     } catch (std::exception& e) {
94460       {
94461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94462       };
94463     } catch (Dali::DaliException e) {
94464       {
94465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94466       };
94467     } catch (...) {
94468       {
94469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94470       };
94471     }
94472   }
94473
94474 }
94475
94476
94477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94478   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94479
94480   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94481   {
94482     try {
94483       delete arg1;
94484     } catch (std::out_of_range& e) {
94485       {
94486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94487       };
94488     } catch (std::exception& e) {
94489       {
94490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94491       };
94492     } catch (Dali::DaliException e) {
94493       {
94494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94495       };
94496     } catch (...) {
94497       {
94498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94499       };
94500     }
94501   }
94502
94503 }
94504
94505
94506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94507   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94508
94509   arg1 = (std::vector< Dali::Actor > *)jarg1;
94510   {
94511     try {
94512       (arg1)->clear();
94513     } catch (std::out_of_range& e) {
94514       {
94515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94516       };
94517     } catch (std::exception& e) {
94518       {
94519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94520       };
94521     } catch (Dali::DaliException e) {
94522       {
94523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94524       };
94525     } catch (...) {
94526       {
94527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94528       };
94529     }
94530   }
94531
94532 }
94533
94534
94535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94536   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94537   Dali::Actor *arg2 = 0 ;
94538
94539   arg1 = (std::vector< Dali::Actor > *)jarg1;
94540   arg2 = (Dali::Actor *)jarg2;
94541   if (!arg2) {
94542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94543     return ;
94544   }
94545   {
94546     try {
94547       (arg1)->push_back((Dali::Actor const &)*arg2);
94548     } catch (std::out_of_range& e) {
94549       {
94550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94551       };
94552     } catch (std::exception& e) {
94553       {
94554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94555       };
94556     } catch (Dali::DaliException e) {
94557       {
94558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94559       };
94560     } catch (...) {
94561       {
94562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94563       };
94564     }
94565   }
94566
94567 }
94568
94569
94570 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94571   unsigned long jresult ;
94572   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94573   std::vector< Dali::Actor >::size_type result;
94574
94575   arg1 = (std::vector< Dali::Actor > *)jarg1;
94576   {
94577     try {
94578       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94579     } catch (std::out_of_range& e) {
94580       {
94581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94582       };
94583     } catch (std::exception& e) {
94584       {
94585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94586       };
94587     } catch (Dali::DaliException e) {
94588       {
94589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94590       };
94591     } catch (...) {
94592       {
94593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94594       };
94595     }
94596   }
94597
94598   jresult = (unsigned long)result;
94599   return jresult;
94600 }
94601
94602
94603 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94604   unsigned long jresult ;
94605   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94606   std::vector< Dali::Actor >::size_type result;
94607
94608   arg1 = (std::vector< Dali::Actor > *)jarg1;
94609   {
94610     try {
94611       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94612     } catch (std::out_of_range& e) {
94613       {
94614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94615       };
94616     } catch (std::exception& e) {
94617       {
94618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94619       };
94620     } catch (Dali::DaliException e) {
94621       {
94622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94623       };
94624     } catch (...) {
94625       {
94626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94627       };
94628     }
94629   }
94630
94631   jresult = (unsigned long)result;
94632   return jresult;
94633 }
94634
94635
94636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94637   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94638   std::vector< Dali::Actor >::size_type arg2 ;
94639
94640   arg1 = (std::vector< Dali::Actor > *)jarg1;
94641   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94642   {
94643     try {
94644       (arg1)->reserve(arg2);
94645     } catch (std::out_of_range& e) {
94646       {
94647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94648       };
94649     } catch (std::exception& e) {
94650       {
94651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94652       };
94653     } catch (Dali::DaliException e) {
94654       {
94655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94656       };
94657     } catch (...) {
94658       {
94659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94660       };
94661     }
94662   }
94663
94664 }
94665
94666
94667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94668   void * jresult ;
94669   std::vector< Dali::Actor > *result = 0 ;
94670
94671   {
94672     try {
94673       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94674     } catch (std::out_of_range& e) {
94675       {
94676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94677       };
94678     } catch (std::exception& e) {
94679       {
94680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94681       };
94682     } catch (Dali::DaliException e) {
94683       {
94684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94685       };
94686     } catch (...) {
94687       {
94688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94689       };
94690     }
94691   }
94692
94693   jresult = (void *)result;
94694   return jresult;
94695 }
94696
94697
94698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94699   void * jresult ;
94700   std::vector< Dali::Actor > *arg1 = 0 ;
94701   std::vector< Dali::Actor > *result = 0 ;
94702
94703   arg1 = (std::vector< Dali::Actor > *)jarg1;
94704   if (!arg1) {
94705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94706     return 0;
94707   }
94708   {
94709     try {
94710       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94711     } catch (std::out_of_range& e) {
94712       {
94713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94714       };
94715     } catch (std::exception& e) {
94716       {
94717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94718       };
94719     } catch (Dali::DaliException e) {
94720       {
94721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94722       };
94723     } catch (...) {
94724       {
94725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94726       };
94727     }
94728   }
94729
94730   jresult = (void *)result;
94731   return jresult;
94732 }
94733
94734
94735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94736   void * jresult ;
94737   int arg1 ;
94738   std::vector< Dali::Actor > *result = 0 ;
94739
94740   arg1 = (int)jarg1;
94741   {
94742     try {
94743       try {
94744         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94745       }
94746       catch(std::out_of_range &_e) {
94747         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94748         return 0;
94749       }
94750
94751     } catch (std::out_of_range& e) {
94752       {
94753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94754       };
94755     } catch (std::exception& e) {
94756       {
94757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94758       };
94759     } catch (Dali::DaliException e) {
94760       {
94761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94762       };
94763     } catch (...) {
94764       {
94765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94766       };
94767     }
94768   }
94769
94770   jresult = (void *)result;
94771   return jresult;
94772 }
94773
94774
94775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94776   void * jresult ;
94777   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94778   int arg2 ;
94779   Dali::Actor result;
94780
94781   arg1 = (std::vector< Dali::Actor > *)jarg1;
94782   arg2 = (int)jarg2;
94783   {
94784     try {
94785       try {
94786         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94787       }
94788       catch(std::out_of_range &_e) {
94789         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94790         return 0;
94791       }
94792
94793     } catch (std::out_of_range& e) {
94794       {
94795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94796       };
94797     } catch (std::exception& e) {
94798       {
94799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94800       };
94801     } catch (Dali::DaliException e) {
94802       {
94803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94804       };
94805     } catch (...) {
94806       {
94807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94808       };
94809     }
94810   }
94811
94812   jresult = new Dali::Actor((const Dali::Actor &)result);
94813   return jresult;
94814 }
94815
94816
94817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94818   void * jresult ;
94819   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94820   int arg2 ;
94821   Dali::Actor *result = 0 ;
94822
94823   arg1 = (std::vector< Dali::Actor > *)jarg1;
94824   arg2 = (int)jarg2;
94825   {
94826     try {
94827       try {
94828         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94829       }
94830       catch(std::out_of_range &_e) {
94831         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94832         return 0;
94833       }
94834
94835     } catch (std::out_of_range& e) {
94836       {
94837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94838       };
94839     } catch (std::exception& e) {
94840       {
94841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94842       };
94843     } catch (Dali::DaliException e) {
94844       {
94845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94846       };
94847     } catch (...) {
94848       {
94849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94850       };
94851     }
94852   }
94853
94854   jresult = (void *)result;
94855   return jresult;
94856 }
94857
94858
94859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94860   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94861   int arg2 ;
94862   Dali::Actor *arg3 = 0 ;
94863
94864   arg1 = (std::vector< Dali::Actor > *)jarg1;
94865   arg2 = (int)jarg2;
94866   arg3 = (Dali::Actor *)jarg3;
94867   if (!arg3) {
94868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94869     return ;
94870   }
94871   {
94872     try {
94873       try {
94874         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94875       }
94876       catch(std::out_of_range &_e) {
94877         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94878         return ;
94879       }
94880
94881     } catch (std::out_of_range& e) {
94882       {
94883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94884       };
94885     } catch (std::exception& e) {
94886       {
94887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94888       };
94889     } catch (Dali::DaliException e) {
94890       {
94891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94892       };
94893     } catch (...) {
94894       {
94895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94896       };
94897     }
94898   }
94899
94900 }
94901
94902
94903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94904   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94905   std::vector< Dali::Actor > *arg2 = 0 ;
94906
94907   arg1 = (std::vector< Dali::Actor > *)jarg1;
94908   arg2 = (std::vector< Dali::Actor > *)jarg2;
94909   if (!arg2) {
94910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94911     return ;
94912   }
94913   {
94914     try {
94915       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
94916     } catch (std::out_of_range& e) {
94917       {
94918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94919       };
94920     } catch (std::exception& e) {
94921       {
94922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94923       };
94924     } catch (Dali::DaliException e) {
94925       {
94926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94927       };
94928     } catch (...) {
94929       {
94930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94931       };
94932     }
94933   }
94934
94935 }
94936
94937
94938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94939   void * jresult ;
94940   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94941   int arg2 ;
94942   int arg3 ;
94943   std::vector< Dali::Actor > *result = 0 ;
94944
94945   arg1 = (std::vector< Dali::Actor > *)jarg1;
94946   arg2 = (int)jarg2;
94947   arg3 = (int)jarg3;
94948   {
94949     try {
94950       try {
94951         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94952       }
94953       catch(std::out_of_range &_e) {
94954         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94955         return 0;
94956       }
94957       catch(std::invalid_argument &_e) {
94958         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94959         return 0;
94960       }
94961
94962     } catch (std::out_of_range& e) {
94963       {
94964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94965       };
94966     } catch (std::exception& e) {
94967       {
94968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94969       };
94970     } catch (Dali::DaliException e) {
94971       {
94972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94973       };
94974     } catch (...) {
94975       {
94976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94977       };
94978     }
94979   }
94980
94981   jresult = (void *)result;
94982   return jresult;
94983 }
94984
94985
94986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94987   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94988   int arg2 ;
94989   Dali::Actor *arg3 = 0 ;
94990
94991   arg1 = (std::vector< Dali::Actor > *)jarg1;
94992   arg2 = (int)jarg2;
94993   arg3 = (Dali::Actor *)jarg3;
94994   if (!arg3) {
94995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94996     return ;
94997   }
94998   {
94999     try {
95000       try {
95001         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95002       }
95003       catch(std::out_of_range &_e) {
95004         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95005         return ;
95006       }
95007
95008     } catch (std::out_of_range& e) {
95009       {
95010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95011       };
95012     } catch (std::exception& e) {
95013       {
95014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95015       };
95016     } catch (Dali::DaliException e) {
95017       {
95018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95019       };
95020     } catch (...) {
95021       {
95022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95023       };
95024     }
95025   }
95026
95027 }
95028
95029
95030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95031   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95032   int arg2 ;
95033   std::vector< Dali::Actor > *arg3 = 0 ;
95034
95035   arg1 = (std::vector< Dali::Actor > *)jarg1;
95036   arg2 = (int)jarg2;
95037   arg3 = (std::vector< Dali::Actor > *)jarg3;
95038   if (!arg3) {
95039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95040     return ;
95041   }
95042   {
95043     try {
95044       try {
95045         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95046       }
95047       catch(std::out_of_range &_e) {
95048         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95049         return ;
95050       }
95051
95052     } catch (std::out_of_range& e) {
95053       {
95054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95055       };
95056     } catch (std::exception& e) {
95057       {
95058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95059       };
95060     } catch (Dali::DaliException e) {
95061       {
95062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95063       };
95064     } catch (...) {
95065       {
95066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95067       };
95068     }
95069   }
95070
95071 }
95072
95073
95074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95075   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95076   int arg2 ;
95077
95078   arg1 = (std::vector< Dali::Actor > *)jarg1;
95079   arg2 = (int)jarg2;
95080   {
95081     try {
95082       try {
95083         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95084       }
95085       catch(std::out_of_range &_e) {
95086         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95087         return ;
95088       }
95089
95090     } catch (std::out_of_range& e) {
95091       {
95092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95093       };
95094     } catch (std::exception& e) {
95095       {
95096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95097       };
95098     } catch (Dali::DaliException e) {
95099       {
95100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95101       };
95102     } catch (...) {
95103       {
95104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95105       };
95106     }
95107   }
95108
95109 }
95110
95111
95112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95113   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95114   int arg2 ;
95115   int arg3 ;
95116
95117   arg1 = (std::vector< Dali::Actor > *)jarg1;
95118   arg2 = (int)jarg2;
95119   arg3 = (int)jarg3;
95120   {
95121     try {
95122       try {
95123         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95124       }
95125       catch(std::out_of_range &_e) {
95126         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95127         return ;
95128       }
95129       catch(std::invalid_argument &_e) {
95130         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95131         return ;
95132       }
95133
95134     } catch (std::out_of_range& e) {
95135       {
95136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95137       };
95138     } catch (std::exception& e) {
95139       {
95140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95141       };
95142     } catch (Dali::DaliException e) {
95143       {
95144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95145       };
95146     } catch (...) {
95147       {
95148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95149       };
95150     }
95151   }
95152
95153 }
95154
95155
95156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95157   void * jresult ;
95158   Dali::Actor *arg1 = 0 ;
95159   int arg2 ;
95160   std::vector< Dali::Actor > *result = 0 ;
95161
95162   arg1 = (Dali::Actor *)jarg1;
95163   if (!arg1) {
95164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95165     return 0;
95166   }
95167   arg2 = (int)jarg2;
95168   {
95169     try {
95170       try {
95171         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95172       }
95173       catch(std::out_of_range &_e) {
95174         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95175         return 0;
95176       }
95177
95178     } catch (std::out_of_range& e) {
95179       {
95180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95181       };
95182     } catch (std::exception& e) {
95183       {
95184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95185       };
95186     } catch (Dali::DaliException e) {
95187       {
95188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95189       };
95190     } catch (...) {
95191       {
95192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95193       };
95194     }
95195   }
95196
95197   jresult = (void *)result;
95198   return jresult;
95199 }
95200
95201
95202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95203   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95204
95205   arg1 = (std::vector< Dali::Actor > *)jarg1;
95206   {
95207     try {
95208       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95209     } catch (std::out_of_range& e) {
95210       {
95211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95212       };
95213     } catch (std::exception& e) {
95214       {
95215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95216       };
95217     } catch (Dali::DaliException e) {
95218       {
95219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95220       };
95221     } catch (...) {
95222       {
95223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95224       };
95225     }
95226   }
95227
95228 }
95229
95230
95231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95232   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95233   int arg2 ;
95234   int arg3 ;
95235
95236   arg1 = (std::vector< Dali::Actor > *)jarg1;
95237   arg2 = (int)jarg2;
95238   arg3 = (int)jarg3;
95239   {
95240     try {
95241       try {
95242         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95243       }
95244       catch(std::out_of_range &_e) {
95245         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95246         return ;
95247       }
95248       catch(std::invalid_argument &_e) {
95249         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95250         return ;
95251       }
95252
95253     } catch (std::out_of_range& e) {
95254       {
95255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95256       };
95257     } catch (std::exception& e) {
95258       {
95259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95260       };
95261     } catch (Dali::DaliException e) {
95262       {
95263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95264       };
95265     } catch (...) {
95266       {
95267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95268       };
95269     }
95270   }
95271
95272 }
95273
95274
95275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95276   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95277   int arg2 ;
95278   std::vector< Dali::Actor > *arg3 = 0 ;
95279
95280   arg1 = (std::vector< Dali::Actor > *)jarg1;
95281   arg2 = (int)jarg2;
95282   arg3 = (std::vector< Dali::Actor > *)jarg3;
95283   if (!arg3) {
95284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95285     return ;
95286   }
95287   {
95288     try {
95289       try {
95290         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95291       }
95292       catch(std::out_of_range &_e) {
95293         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95294         return ;
95295       }
95296
95297     } catch (std::out_of_range& e) {
95298       {
95299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95300       };
95301     } catch (std::exception& e) {
95302       {
95303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95304       };
95305     } catch (Dali::DaliException e) {
95306       {
95307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95308       };
95309     } catch (...) {
95310       {
95311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95312       };
95313     }
95314   }
95315
95316 }
95317
95318
95319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95320   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95321
95322   arg1 = (std::vector< Dali::Actor > *)jarg1;
95323   {
95324     try {
95325       delete arg1;
95326     } catch (std::out_of_range& e) {
95327       {
95328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95329       };
95330     } catch (std::exception& e) {
95331       {
95332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95333       };
95334     } catch (Dali::DaliException e) {
95335       {
95336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95337       };
95338     } catch (...) {
95339       {
95340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95341       };
95342     }
95343   }
95344
95345 }
95346
95347
95348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95349   unsigned int jresult ;
95350   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95351   bool result;
95352
95353   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95354   {
95355     try {
95356       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95357     } catch (std::out_of_range& e) {
95358       {
95359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95360       };
95361     } catch (std::exception& e) {
95362       {
95363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95364       };
95365     } catch (Dali::DaliException e) {
95366       {
95367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95368       };
95369     } catch (...) {
95370       {
95371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95372       };
95373     }
95374   }
95375
95376   jresult = result;
95377   return jresult;
95378 }
95379
95380
95381 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95382   unsigned long jresult ;
95383   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95384   std::size_t result;
95385
95386   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95387   {
95388     try {
95389       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95390     } catch (std::out_of_range& e) {
95391       {
95392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95393       };
95394     } catch (std::exception& e) {
95395       {
95396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95397       };
95398     } catch (Dali::DaliException e) {
95399       {
95400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95401       };
95402     } catch (...) {
95403       {
95404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95405       };
95406     }
95407   }
95408
95409   jresult = (unsigned long)result;
95410   return jresult;
95411 }
95412
95413
95414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95415   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95416   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95417
95418   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95419   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95420   {
95421     try {
95422       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95423     } catch (std::out_of_range& e) {
95424       {
95425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95426       };
95427     } catch (std::exception& e) {
95428       {
95429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95430       };
95431     } catch (Dali::DaliException e) {
95432       {
95433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95434       };
95435     } catch (...) {
95436       {
95437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95438       };
95439     }
95440   }
95441
95442 }
95443
95444
95445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95446   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95447   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95448
95449   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95450   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95451   {
95452     try {
95453       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95454     } catch (std::out_of_range& e) {
95455       {
95456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95457       };
95458     } catch (std::exception& e) {
95459       {
95460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95461       };
95462     } catch (Dali::DaliException e) {
95463       {
95464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95465       };
95466     } catch (...) {
95467       {
95468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95469       };
95470     }
95471   }
95472
95473 }
95474
95475
95476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95477   unsigned int jresult ;
95478   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95479   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95480   bool result;
95481
95482   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95483   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95484   if (!arg2) {
95485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95486     return 0;
95487   }
95488   {
95489     try {
95490       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95491     } catch (std::out_of_range& e) {
95492       {
95493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95494       };
95495     } catch (std::exception& e) {
95496       {
95497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95498       };
95499     } catch (Dali::DaliException e) {
95500       {
95501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95502       };
95503     } catch (...) {
95504       {
95505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95506       };
95507     }
95508   }
95509
95510   jresult = result;
95511   return jresult;
95512 }
95513
95514
95515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95516   void * jresult ;
95517   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95518
95519   {
95520     try {
95521       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95522     } catch (std::out_of_range& e) {
95523       {
95524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95525       };
95526     } catch (std::exception& e) {
95527       {
95528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95529       };
95530     } catch (Dali::DaliException e) {
95531       {
95532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95533       };
95534     } catch (...) {
95535       {
95536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95537       };
95538     }
95539   }
95540
95541   jresult = (void *)result;
95542   return jresult;
95543 }
95544
95545
95546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95547   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95548
95549   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95550   {
95551     try {
95552       delete arg1;
95553     } catch (std::out_of_range& e) {
95554       {
95555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95556       };
95557     } catch (std::exception& e) {
95558       {
95559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95560       };
95561     } catch (Dali::DaliException e) {
95562       {
95563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95564       };
95565     } catch (...) {
95566       {
95567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95568       };
95569     }
95570   }
95571
95572 }
95573
95574
95575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95576   unsigned int jresult ;
95577   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95578   bool result;
95579
95580   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95581   {
95582     try {
95583       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);
95584     } catch (std::out_of_range& e) {
95585       {
95586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95587       };
95588     } catch (std::exception& e) {
95589       {
95590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95591       };
95592     } catch (Dali::DaliException e) {
95593       {
95594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95595       };
95596     } catch (...) {
95597       {
95598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95599       };
95600     }
95601   }
95602
95603   jresult = result;
95604   return jresult;
95605 }
95606
95607
95608 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95609   unsigned long jresult ;
95610   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95611   std::size_t result;
95612
95613   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95614   {
95615     try {
95616       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);
95617     } catch (std::out_of_range& e) {
95618       {
95619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95620       };
95621     } catch (std::exception& e) {
95622       {
95623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95624       };
95625     } catch (Dali::DaliException e) {
95626       {
95627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95628       };
95629     } catch (...) {
95630       {
95631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95632       };
95633     }
95634   }
95635
95636   jresult = (unsigned long)result;
95637   return jresult;
95638 }
95639
95640
95641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95642   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95643   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95644
95645   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95646   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95647   {
95648     try {
95649       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95650     } catch (std::out_of_range& e) {
95651       {
95652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95653       };
95654     } catch (std::exception& e) {
95655       {
95656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95657       };
95658     } catch (Dali::DaliException e) {
95659       {
95660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95661       };
95662     } catch (...) {
95663       {
95664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95665       };
95666     }
95667   }
95668
95669 }
95670
95671
95672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95673   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95674   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95675
95676   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95677   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95678   {
95679     try {
95680       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95681     } catch (std::out_of_range& e) {
95682       {
95683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95684       };
95685     } catch (std::exception& e) {
95686       {
95687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95688       };
95689     } catch (Dali::DaliException e) {
95690       {
95691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95692       };
95693     } catch (...) {
95694       {
95695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95696       };
95697     }
95698   }
95699
95700 }
95701
95702
95703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95704   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95705   Dali::Actor arg2 ;
95706   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95707   Dali::Actor *argp2 ;
95708
95709   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95710   argp2 = (Dali::Actor *)jarg2;
95711   if (!argp2) {
95712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95713     return ;
95714   }
95715   arg2 = *argp2;
95716   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95717   {
95718     try {
95719       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95720     } catch (std::out_of_range& e) {
95721       {
95722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95723       };
95724     } catch (std::exception& e) {
95725       {
95726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95727       };
95728     } catch (Dali::DaliException e) {
95729       {
95730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95731       };
95732     } catch (...) {
95733       {
95734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95735       };
95736     }
95737   }
95738
95739 }
95740
95741
95742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95743   void * jresult ;
95744   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95745
95746   {
95747     try {
95748       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95749     } catch (std::out_of_range& e) {
95750       {
95751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95752       };
95753     } catch (std::exception& e) {
95754       {
95755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95756       };
95757     } catch (Dali::DaliException e) {
95758       {
95759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95760       };
95761     } catch (...) {
95762       {
95763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95764       };
95765     }
95766   }
95767
95768   jresult = (void *)result;
95769   return jresult;
95770 }
95771
95772
95773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95774   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95775
95776   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95777   {
95778     try {
95779       delete arg1;
95780     } catch (std::out_of_range& e) {
95781       {
95782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95783       };
95784     } catch (std::exception& e) {
95785       {
95786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95787       };
95788     } catch (Dali::DaliException e) {
95789       {
95790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95791       };
95792     } catch (...) {
95793       {
95794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95795       };
95796     }
95797   }
95798
95799 }
95800
95801
95802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95803   unsigned int jresult ;
95804   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95805   bool result;
95806
95807   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95808   {
95809     try {
95810       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95811     } catch (std::out_of_range& e) {
95812       {
95813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95814       };
95815     } catch (std::exception& e) {
95816       {
95817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95818       };
95819     } catch (Dali::DaliException e) {
95820       {
95821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95822       };
95823     } catch (...) {
95824       {
95825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95826       };
95827     }
95828   }
95829
95830   jresult = result;
95831   return jresult;
95832 }
95833
95834
95835 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95836   unsigned long jresult ;
95837   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95838   std::size_t result;
95839
95840   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95841   {
95842     try {
95843       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95844     } catch (std::out_of_range& e) {
95845       {
95846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95847       };
95848     } catch (std::exception& e) {
95849       {
95850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95851       };
95852     } catch (Dali::DaliException e) {
95853       {
95854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95855       };
95856     } catch (...) {
95857       {
95858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95859       };
95860     }
95861   }
95862
95863   jresult = (unsigned long)result;
95864   return jresult;
95865 }
95866
95867
95868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95869   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95870   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95871
95872   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95873   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95874   {
95875     try {
95876       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95877     } catch (std::out_of_range& e) {
95878       {
95879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95880       };
95881     } catch (std::exception& e) {
95882       {
95883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95884       };
95885     } catch (Dali::DaliException e) {
95886       {
95887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95888       };
95889     } catch (...) {
95890       {
95891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95892       };
95893     }
95894   }
95895
95896 }
95897
95898
95899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95900   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95901   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95902
95903   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95904   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95905   {
95906     try {
95907       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95908     } catch (std::out_of_range& e) {
95909       {
95910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95911       };
95912     } catch (std::exception& e) {
95913       {
95914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95915       };
95916     } catch (Dali::DaliException e) {
95917       {
95918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95919       };
95920     } catch (...) {
95921       {
95922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95923       };
95924     }
95925   }
95926
95927 }
95928
95929
95930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95931   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95932   Dali::Actor arg2 ;
95933   Dali::Actor arg3 ;
95934   Dali::Actor *argp2 ;
95935   Dali::Actor *argp3 ;
95936
95937   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95938   argp2 = (Dali::Actor *)jarg2;
95939   if (!argp2) {
95940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95941     return ;
95942   }
95943   arg2 = *argp2;
95944   argp3 = (Dali::Actor *)jarg3;
95945   if (!argp3) {
95946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95947     return ;
95948   }
95949   arg3 = *argp3;
95950   {
95951     try {
95952       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95953     } catch (std::out_of_range& e) {
95954       {
95955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95956       };
95957     } catch (std::exception& e) {
95958       {
95959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95960       };
95961     } catch (Dali::DaliException e) {
95962       {
95963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95964       };
95965     } catch (...) {
95966       {
95967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95968       };
95969     }
95970   }
95971
95972 }
95973
95974
95975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95976   void * jresult ;
95977   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95978
95979   {
95980     try {
95981       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95982     } catch (std::out_of_range& e) {
95983       {
95984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95985       };
95986     } catch (std::exception& e) {
95987       {
95988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95989       };
95990     } catch (Dali::DaliException e) {
95991       {
95992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95993       };
95994     } catch (...) {
95995       {
95996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95997       };
95998     }
95999   }
96000
96001   jresult = (void *)result;
96002   return jresult;
96003 }
96004
96005
96006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96007   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96008
96009   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96010   {
96011     try {
96012       delete arg1;
96013     } catch (std::out_of_range& e) {
96014       {
96015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96016       };
96017     } catch (std::exception& e) {
96018       {
96019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96020       };
96021     } catch (Dali::DaliException e) {
96022       {
96023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96024       };
96025     } catch (...) {
96026       {
96027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96028       };
96029     }
96030   }
96031
96032 }
96033
96034
96035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96036   unsigned int jresult ;
96037   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96038   bool result;
96039
96040   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96041   {
96042     try {
96043       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96044     } catch (std::out_of_range& e) {
96045       {
96046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96047       };
96048     } catch (std::exception& e) {
96049       {
96050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96051       };
96052     } catch (Dali::DaliException e) {
96053       {
96054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96055       };
96056     } catch (...) {
96057       {
96058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96059       };
96060     }
96061   }
96062
96063   jresult = result;
96064   return jresult;
96065 }
96066
96067
96068 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96069   unsigned long jresult ;
96070   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96071   std::size_t result;
96072
96073   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96074   {
96075     try {
96076       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96077     } catch (std::out_of_range& e) {
96078       {
96079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96080       };
96081     } catch (std::exception& e) {
96082       {
96083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96084       };
96085     } catch (Dali::DaliException e) {
96086       {
96087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96088       };
96089     } catch (...) {
96090       {
96091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96092       };
96093     }
96094   }
96095
96096   jresult = (unsigned long)result;
96097   return jresult;
96098 }
96099
96100
96101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96102   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96103   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96104
96105   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96106   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96107   {
96108     try {
96109       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96110     } catch (std::out_of_range& e) {
96111       {
96112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96113       };
96114     } catch (std::exception& e) {
96115       {
96116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96117       };
96118     } catch (Dali::DaliException e) {
96119       {
96120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96121       };
96122     } catch (...) {
96123       {
96124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96125       };
96126     }
96127   }
96128
96129 }
96130
96131
96132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96133   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96134   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96135
96136   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96137   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96138   {
96139     try {
96140       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96141     } catch (std::out_of_range& e) {
96142       {
96143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96144       };
96145     } catch (std::exception& e) {
96146       {
96147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96148       };
96149     } catch (Dali::DaliException e) {
96150       {
96151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96152       };
96153     } catch (...) {
96154       {
96155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96156       };
96157     }
96158   }
96159
96160 }
96161
96162
96163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96164   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96165   Dali::Actor arg2 ;
96166   bool arg3 ;
96167   Dali::Actor *argp2 ;
96168
96169   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96170   argp2 = (Dali::Actor *)jarg2;
96171   if (!argp2) {
96172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96173     return ;
96174   }
96175   arg2 = *argp2;
96176   arg3 = jarg3 ? true : false;
96177   {
96178     try {
96179       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96180     } catch (std::out_of_range& e) {
96181       {
96182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96183       };
96184     } catch (std::exception& e) {
96185       {
96186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96187       };
96188     } catch (Dali::DaliException e) {
96189       {
96190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96191       };
96192     } catch (...) {
96193       {
96194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96195       };
96196     }
96197   }
96198
96199 }
96200
96201
96202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96203   void * jresult ;
96204   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96205
96206   {
96207     try {
96208       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96209     } catch (std::out_of_range& e) {
96210       {
96211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96212       };
96213     } catch (std::exception& e) {
96214       {
96215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96216       };
96217     } catch (Dali::DaliException e) {
96218       {
96219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96220       };
96221     } catch (...) {
96222       {
96223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96224       };
96225     }
96226   }
96227
96228   jresult = (void *)result;
96229   return jresult;
96230 }
96231
96232
96233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96234   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96235
96236   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96237   {
96238     try {
96239       delete arg1;
96240     } catch (std::out_of_range& e) {
96241       {
96242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96243       };
96244     } catch (std::exception& e) {
96245       {
96246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96247       };
96248     } catch (Dali::DaliException e) {
96249       {
96250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96251       };
96252     } catch (...) {
96253       {
96254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96255       };
96256     }
96257   }
96258
96259 }
96260
96261
96262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96263   unsigned int jresult ;
96264   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96265   bool result;
96266
96267   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96268   {
96269     try {
96270       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);
96271     } catch (std::out_of_range& e) {
96272       {
96273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96274       };
96275     } catch (std::exception& e) {
96276       {
96277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96278       };
96279     } catch (Dali::DaliException e) {
96280       {
96281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96282       };
96283     } catch (...) {
96284       {
96285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96286       };
96287     }
96288   }
96289
96290   jresult = result;
96291   return jresult;
96292 }
96293
96294
96295 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96296   unsigned long jresult ;
96297   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96298   std::size_t result;
96299
96300   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96301   {
96302     try {
96303       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);
96304     } catch (std::out_of_range& e) {
96305       {
96306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96307       };
96308     } catch (std::exception& e) {
96309       {
96310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96311       };
96312     } catch (Dali::DaliException e) {
96313       {
96314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96315       };
96316     } catch (...) {
96317       {
96318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96319       };
96320     }
96321   }
96322
96323   jresult = (unsigned long)result;
96324   return jresult;
96325 }
96326
96327
96328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96329   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96330   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96331
96332   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96333   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96334   {
96335     try {
96336       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96337     } catch (std::out_of_range& e) {
96338       {
96339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96340       };
96341     } catch (std::exception& e) {
96342       {
96343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96344       };
96345     } catch (Dali::DaliException e) {
96346       {
96347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96348       };
96349     } catch (...) {
96350       {
96351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96352       };
96353     }
96354   }
96355
96356 }
96357
96358
96359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96360   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96361   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96362
96363   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96364   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96365   {
96366     try {
96367       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96368     } catch (std::out_of_range& e) {
96369       {
96370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96371       };
96372     } catch (std::exception& e) {
96373       {
96374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96375       };
96376     } catch (Dali::DaliException e) {
96377       {
96378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96379       };
96380     } catch (...) {
96381       {
96382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96383       };
96384     }
96385   }
96386
96387 }
96388
96389
96390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96391   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96392   Dali::Toolkit::StyleManager arg2 ;
96393   Dali::StyleChange::Type arg3 ;
96394   Dali::Toolkit::StyleManager *argp2 ;
96395
96396   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96397   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96398   if (!argp2) {
96399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96400     return ;
96401   }
96402   arg2 = *argp2;
96403   arg3 = (Dali::StyleChange::Type)jarg3;
96404   {
96405     try {
96406       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96407     } catch (std::out_of_range& e) {
96408       {
96409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96410       };
96411     } catch (std::exception& e) {
96412       {
96413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96414       };
96415     } catch (Dali::DaliException e) {
96416       {
96417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96418       };
96419     } catch (...) {
96420       {
96421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96422       };
96423     }
96424   }
96425
96426 }
96427
96428
96429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96430   void * jresult ;
96431   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96432
96433   {
96434     try {
96435       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96436     } catch (std::out_of_range& e) {
96437       {
96438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96439       };
96440     } catch (std::exception& e) {
96441       {
96442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96443       };
96444     } catch (Dali::DaliException e) {
96445       {
96446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96447       };
96448     } catch (...) {
96449       {
96450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96451       };
96452     }
96453   }
96454
96455   jresult = (void *)result;
96456   return jresult;
96457 }
96458
96459
96460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96461   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96462
96463   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96464   {
96465     try {
96466       delete arg1;
96467     } catch (std::out_of_range& e) {
96468       {
96469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96470       };
96471     } catch (std::exception& e) {
96472       {
96473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96474       };
96475     } catch (Dali::DaliException e) {
96476       {
96477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96478       };
96479     } catch (...) {
96480       {
96481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96482       };
96483     }
96484   }
96485
96486 }
96487
96488
96489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96490   unsigned int jresult ;
96491   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96492   bool result;
96493
96494   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96495   {
96496     try {
96497       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96498     } catch (std::out_of_range& e) {
96499       {
96500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96501       };
96502     } catch (std::exception& e) {
96503       {
96504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96505       };
96506     } catch (Dali::DaliException e) {
96507       {
96508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96509       };
96510     } catch (...) {
96511       {
96512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96513       };
96514     }
96515   }
96516
96517   jresult = result;
96518   return jresult;
96519 }
96520
96521
96522 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96523   unsigned long jresult ;
96524   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96525   std::size_t result;
96526
96527   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96528   {
96529     try {
96530       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96531     } catch (std::out_of_range& e) {
96532       {
96533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96534       };
96535     } catch (std::exception& e) {
96536       {
96537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96538       };
96539     } catch (Dali::DaliException e) {
96540       {
96541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96542       };
96543     } catch (...) {
96544       {
96545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96546       };
96547     }
96548   }
96549
96550   jresult = (unsigned long)result;
96551   return jresult;
96552 }
96553
96554
96555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96556   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96557   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96558
96559   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96560   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96561   {
96562     try {
96563       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96564     } catch (std::out_of_range& e) {
96565       {
96566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96567       };
96568     } catch (std::exception& e) {
96569       {
96570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96571       };
96572     } catch (Dali::DaliException e) {
96573       {
96574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96575       };
96576     } catch (...) {
96577       {
96578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96579       };
96580     }
96581   }
96582
96583 }
96584
96585
96586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96587   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96588   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96589
96590   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96591   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96592   {
96593     try {
96594       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96595     } catch (std::out_of_range& e) {
96596       {
96597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96598       };
96599     } catch (std::exception& e) {
96600       {
96601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96602       };
96603     } catch (Dali::DaliException e) {
96604       {
96605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96606       };
96607     } catch (...) {
96608       {
96609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96610       };
96611     }
96612   }
96613
96614 }
96615
96616
96617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96618   unsigned int jresult ;
96619   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96620   Dali::Toolkit::Button arg2 ;
96621   Dali::Toolkit::Button *argp2 ;
96622   bool result;
96623
96624   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96625   argp2 = (Dali::Toolkit::Button *)jarg2;
96626   if (!argp2) {
96627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96628     return 0;
96629   }
96630   arg2 = *argp2;
96631   {
96632     try {
96633       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96634     } catch (std::out_of_range& e) {
96635       {
96636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96637       };
96638     } catch (std::exception& e) {
96639       {
96640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96641       };
96642     } catch (Dali::DaliException e) {
96643       {
96644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96645       };
96646     } catch (...) {
96647       {
96648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96649       };
96650     }
96651   }
96652
96653   jresult = result;
96654   return jresult;
96655 }
96656
96657
96658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96659   void * jresult ;
96660   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96661
96662   {
96663     try {
96664       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96665     } catch (std::out_of_range& e) {
96666       {
96667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96668       };
96669     } catch (std::exception& e) {
96670       {
96671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96672       };
96673     } catch (Dali::DaliException e) {
96674       {
96675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96676       };
96677     } catch (...) {
96678       {
96679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96680       };
96681     }
96682   }
96683
96684   jresult = (void *)result;
96685   return jresult;
96686 }
96687
96688
96689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96690   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96691
96692   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96693   {
96694     try {
96695       delete arg1;
96696     } catch (std::out_of_range& e) {
96697       {
96698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96699       };
96700     } catch (std::exception& e) {
96701       {
96702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96703       };
96704     } catch (Dali::DaliException e) {
96705       {
96706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96707       };
96708     } catch (...) {
96709       {
96710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96711       };
96712     }
96713   }
96714
96715 }
96716
96717
96718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96719   unsigned int jresult ;
96720   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96721   bool result;
96722
96723   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96724   {
96725     try {
96726       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96727     } catch (std::out_of_range& e) {
96728       {
96729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96730       };
96731     } catch (std::exception& e) {
96732       {
96733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96734       };
96735     } catch (Dali::DaliException e) {
96736       {
96737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96738       };
96739     } catch (...) {
96740       {
96741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96742       };
96743     }
96744   }
96745
96746   jresult = result;
96747   return jresult;
96748 }
96749
96750
96751 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96752   unsigned long jresult ;
96753   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96754   std::size_t result;
96755
96756   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96757   {
96758     try {
96759       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96760     } catch (std::out_of_range& e) {
96761       {
96762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96763       };
96764     } catch (std::exception& e) {
96765       {
96766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96767       };
96768     } catch (Dali::DaliException e) {
96769       {
96770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96771       };
96772     } catch (...) {
96773       {
96774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96775       };
96776     }
96777   }
96778
96779   jresult = (unsigned long)result;
96780   return jresult;
96781 }
96782
96783
96784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96785   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96786   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96787
96788   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96789   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96790   {
96791     try {
96792       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96793     } catch (std::out_of_range& e) {
96794       {
96795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96796       };
96797     } catch (std::exception& e) {
96798       {
96799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96800       };
96801     } catch (Dali::DaliException e) {
96802       {
96803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96804       };
96805     } catch (...) {
96806       {
96807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96808       };
96809     }
96810   }
96811
96812 }
96813
96814
96815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96816   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96817   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96818
96819   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96820   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96821   {
96822     try {
96823       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96824     } catch (std::out_of_range& e) {
96825       {
96826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96827       };
96828     } catch (std::exception& e) {
96829       {
96830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96831       };
96832     } catch (Dali::DaliException e) {
96833       {
96834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96835       };
96836     } catch (...) {
96837       {
96838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96839       };
96840     }
96841   }
96842
96843 }
96844
96845
96846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96847   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96848   Dali::Toolkit::GaussianBlurView arg2 ;
96849   Dali::Toolkit::GaussianBlurView *argp2 ;
96850
96851   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96852   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96853   if (!argp2) {
96854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96855     return ;
96856   }
96857   arg2 = *argp2;
96858   {
96859     try {
96860       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96861     } catch (std::out_of_range& e) {
96862       {
96863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96864       };
96865     } catch (std::exception& e) {
96866       {
96867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96868       };
96869     } catch (Dali::DaliException e) {
96870       {
96871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96872       };
96873     } catch (...) {
96874       {
96875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96876       };
96877     }
96878   }
96879
96880 }
96881
96882
96883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96884   void * jresult ;
96885   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96886
96887   {
96888     try {
96889       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96890     } catch (std::out_of_range& e) {
96891       {
96892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96893       };
96894     } catch (std::exception& e) {
96895       {
96896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96897       };
96898     } catch (Dali::DaliException e) {
96899       {
96900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96901       };
96902     } catch (...) {
96903       {
96904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96905       };
96906     }
96907   }
96908
96909   jresult = (void *)result;
96910   return jresult;
96911 }
96912
96913
96914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96915   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96916
96917   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96918   {
96919     try {
96920       delete arg1;
96921     } catch (std::out_of_range& e) {
96922       {
96923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96924       };
96925     } catch (std::exception& e) {
96926       {
96927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96928       };
96929     } catch (Dali::DaliException e) {
96930       {
96931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96932       };
96933     } catch (...) {
96934       {
96935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96936       };
96937     }
96938   }
96939
96940 }
96941
96942
96943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96944   unsigned int jresult ;
96945   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96946   bool result;
96947
96948   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96949   {
96950     try {
96951       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);
96952     } catch (std::out_of_range& e) {
96953       {
96954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96955       };
96956     } catch (std::exception& e) {
96957       {
96958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96959       };
96960     } catch (Dali::DaliException e) {
96961       {
96962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96963       };
96964     } catch (...) {
96965       {
96966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96967       };
96968     }
96969   }
96970
96971   jresult = result;
96972   return jresult;
96973 }
96974
96975
96976 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96977   unsigned long jresult ;
96978   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96979   std::size_t result;
96980
96981   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96982   {
96983     try {
96984       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);
96985     } catch (std::out_of_range& e) {
96986       {
96987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96988       };
96989     } catch (std::exception& e) {
96990       {
96991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96992       };
96993     } catch (Dali::DaliException e) {
96994       {
96995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96996       };
96997     } catch (...) {
96998       {
96999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97000       };
97001     }
97002   }
97003
97004   jresult = (unsigned long)result;
97005   return jresult;
97006 }
97007
97008
97009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97010   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97011   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97012
97013   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97014   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97015   {
97016     try {
97017       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97018     } catch (std::out_of_range& e) {
97019       {
97020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97021       };
97022     } catch (std::exception& e) {
97023       {
97024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97025       };
97026     } catch (Dali::DaliException e) {
97027       {
97028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97029       };
97030     } catch (...) {
97031       {
97032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97033       };
97034     }
97035   }
97036
97037 }
97038
97039
97040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97041   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97042   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97043
97044   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97045   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97046   {
97047     try {
97048       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97049     } catch (std::out_of_range& e) {
97050       {
97051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97052       };
97053     } catch (std::exception& e) {
97054       {
97055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97056       };
97057     } catch (Dali::DaliException e) {
97058       {
97059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97060       };
97061     } catch (...) {
97062       {
97063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97064       };
97065     }
97066   }
97067
97068 }
97069
97070
97071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97072   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97073   Dali::Toolkit::PageTurnView arg2 ;
97074   unsigned int arg3 ;
97075   bool arg4 ;
97076   Dali::Toolkit::PageTurnView *argp2 ;
97077
97078   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97079   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97080   if (!argp2) {
97081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97082     return ;
97083   }
97084   arg2 = *argp2;
97085   arg3 = (unsigned int)jarg3;
97086   arg4 = jarg4 ? true : false;
97087   {
97088     try {
97089       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97090     } catch (std::out_of_range& e) {
97091       {
97092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97093       };
97094     } catch (std::exception& e) {
97095       {
97096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97097       };
97098     } catch (Dali::DaliException e) {
97099       {
97100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97101       };
97102     } catch (...) {
97103       {
97104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97105       };
97106     }
97107   }
97108
97109 }
97110
97111
97112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97113   void * jresult ;
97114   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97115
97116   {
97117     try {
97118       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97119     } catch (std::out_of_range& e) {
97120       {
97121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97122       };
97123     } catch (std::exception& e) {
97124       {
97125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97126       };
97127     } catch (Dali::DaliException e) {
97128       {
97129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97130       };
97131     } catch (...) {
97132       {
97133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97134       };
97135     }
97136   }
97137
97138   jresult = (void *)result;
97139   return jresult;
97140 }
97141
97142
97143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97144   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97145
97146   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97147   {
97148     try {
97149       delete arg1;
97150     } catch (std::out_of_range& e) {
97151       {
97152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97153       };
97154     } catch (std::exception& e) {
97155       {
97156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97157       };
97158     } catch (Dali::DaliException e) {
97159       {
97160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97161       };
97162     } catch (...) {
97163       {
97164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97165       };
97166     }
97167   }
97168
97169 }
97170
97171
97172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97173   unsigned int jresult ;
97174   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97175   bool result;
97176
97177   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97178   {
97179     try {
97180       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97181     } catch (std::out_of_range& e) {
97182       {
97183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97184       };
97185     } catch (std::exception& e) {
97186       {
97187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97188       };
97189     } catch (Dali::DaliException e) {
97190       {
97191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97192       };
97193     } catch (...) {
97194       {
97195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97196       };
97197     }
97198   }
97199
97200   jresult = result;
97201   return jresult;
97202 }
97203
97204
97205 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97206   unsigned long jresult ;
97207   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97208   std::size_t result;
97209
97210   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97211   {
97212     try {
97213       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97214     } catch (std::out_of_range& e) {
97215       {
97216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97217       };
97218     } catch (std::exception& e) {
97219       {
97220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97221       };
97222     } catch (Dali::DaliException e) {
97223       {
97224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97225       };
97226     } catch (...) {
97227       {
97228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97229       };
97230     }
97231   }
97232
97233   jresult = (unsigned long)result;
97234   return jresult;
97235 }
97236
97237
97238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97239   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97240   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97241
97242   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97243   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97244   {
97245     try {
97246       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97247     } catch (std::out_of_range& e) {
97248       {
97249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97250       };
97251     } catch (std::exception& e) {
97252       {
97253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97254       };
97255     } catch (Dali::DaliException e) {
97256       {
97257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97258       };
97259     } catch (...) {
97260       {
97261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97262       };
97263     }
97264   }
97265
97266 }
97267
97268
97269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97270   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97271   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97272
97273   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97274   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97275   {
97276     try {
97277       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97278     } catch (std::out_of_range& e) {
97279       {
97280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97281       };
97282     } catch (std::exception& e) {
97283       {
97284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97285       };
97286     } catch (Dali::DaliException e) {
97287       {
97288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97289       };
97290     } catch (...) {
97291       {
97292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97293       };
97294     }
97295   }
97296
97297 }
97298
97299
97300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97301   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97302   Dali::Toolkit::PageTurnView arg2 ;
97303   Dali::Toolkit::PageTurnView *argp2 ;
97304
97305   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97306   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97307   if (!argp2) {
97308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97309     return ;
97310   }
97311   arg2 = *argp2;
97312   {
97313     try {
97314       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97315     } catch (std::out_of_range& e) {
97316       {
97317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97318       };
97319     } catch (std::exception& e) {
97320       {
97321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97322       };
97323     } catch (Dali::DaliException e) {
97324       {
97325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97326       };
97327     } catch (...) {
97328       {
97329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97330       };
97331     }
97332   }
97333
97334 }
97335
97336
97337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97338   void * jresult ;
97339   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97340
97341   {
97342     try {
97343       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97344     } catch (std::out_of_range& e) {
97345       {
97346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97347       };
97348     } catch (std::exception& e) {
97349       {
97350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97351       };
97352     } catch (Dali::DaliException e) {
97353       {
97354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97355       };
97356     } catch (...) {
97357       {
97358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97359       };
97360     }
97361   }
97362
97363   jresult = (void *)result;
97364   return jresult;
97365 }
97366
97367
97368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97369   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97370
97371   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97372   {
97373     try {
97374       delete arg1;
97375     } catch (std::out_of_range& e) {
97376       {
97377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97378       };
97379     } catch (std::exception& e) {
97380       {
97381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97382       };
97383     } catch (Dali::DaliException e) {
97384       {
97385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97386       };
97387     } catch (...) {
97388       {
97389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97390       };
97391     }
97392   }
97393
97394 }
97395
97396
97397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97398   unsigned int jresult ;
97399   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97400   bool result;
97401
97402   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97403   {
97404     try {
97405       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);
97406     } catch (std::out_of_range& e) {
97407       {
97408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97409       };
97410     } catch (std::exception& e) {
97411       {
97412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97413       };
97414     } catch (Dali::DaliException e) {
97415       {
97416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97417       };
97418     } catch (...) {
97419       {
97420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97421       };
97422     }
97423   }
97424
97425   jresult = result;
97426   return jresult;
97427 }
97428
97429
97430 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97431   unsigned long jresult ;
97432   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97433   std::size_t result;
97434
97435   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97436   {
97437     try {
97438       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);
97439     } catch (std::out_of_range& e) {
97440       {
97441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97442       };
97443     } catch (std::exception& e) {
97444       {
97445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97446       };
97447     } catch (Dali::DaliException e) {
97448       {
97449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97450       };
97451     } catch (...) {
97452       {
97453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97454       };
97455     }
97456   }
97457
97458   jresult = (unsigned long)result;
97459   return jresult;
97460 }
97461
97462
97463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97464   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97465   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97466
97467   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97468   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97469   {
97470     try {
97471       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97472     } catch (std::out_of_range& e) {
97473       {
97474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97475       };
97476     } catch (std::exception& e) {
97477       {
97478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97479       };
97480     } catch (Dali::DaliException e) {
97481       {
97482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97483       };
97484     } catch (...) {
97485       {
97486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97487       };
97488     }
97489   }
97490
97491 }
97492
97493
97494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97495   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97496   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97497
97498   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97499   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97500   {
97501     try {
97502       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97503     } catch (std::out_of_range& e) {
97504       {
97505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97506       };
97507     } catch (std::exception& e) {
97508       {
97509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97510       };
97511     } catch (Dali::DaliException e) {
97512       {
97513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97514       };
97515     } catch (...) {
97516       {
97517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97518       };
97519     }
97520   }
97521
97522 }
97523
97524
97525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97526   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97527   Dali::Toolkit::ProgressBar arg2 ;
97528   float arg3 ;
97529   float arg4 ;
97530   Dali::Toolkit::ProgressBar *argp2 ;
97531
97532   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97533   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97534   if (!argp2) {
97535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97536     return ;
97537   }
97538   arg2 = *argp2;
97539   arg3 = (float)jarg3;
97540   arg4 = (float)jarg4;
97541   {
97542     try {
97543       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97544     } catch (std::out_of_range& e) {
97545       {
97546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97547       };
97548     } catch (std::exception& e) {
97549       {
97550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97551       };
97552     } catch (Dali::DaliException e) {
97553       {
97554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97555       };
97556     } catch (...) {
97557       {
97558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97559       };
97560     }
97561   }
97562
97563 }
97564
97565
97566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97567   void * jresult ;
97568   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97569
97570   {
97571     try {
97572       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97573     } catch (std::out_of_range& e) {
97574       {
97575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97576       };
97577     } catch (std::exception& e) {
97578       {
97579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97580       };
97581     } catch (Dali::DaliException e) {
97582       {
97583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97584       };
97585     } catch (...) {
97586       {
97587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97588       };
97589     }
97590   }
97591
97592   jresult = (void *)result;
97593   return jresult;
97594 }
97595
97596
97597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97598   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97599
97600   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97601   {
97602     try {
97603       delete arg1;
97604     } catch (std::out_of_range& e) {
97605       {
97606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97607       };
97608     } catch (std::exception& e) {
97609       {
97610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97611       };
97612     } catch (Dali::DaliException e) {
97613       {
97614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97615       };
97616     } catch (...) {
97617       {
97618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97619       };
97620     }
97621   }
97622
97623 }
97624
97625
97626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97627   unsigned int jresult ;
97628   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97629   bool result;
97630
97631   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97632   {
97633     try {
97634       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);
97635     } catch (std::out_of_range& e) {
97636       {
97637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97638       };
97639     } catch (std::exception& e) {
97640       {
97641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97642       };
97643     } catch (Dali::DaliException e) {
97644       {
97645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97646       };
97647     } catch (...) {
97648       {
97649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97650       };
97651     }
97652   }
97653
97654   jresult = result;
97655   return jresult;
97656 }
97657
97658
97659 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97660   unsigned long jresult ;
97661   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97662   std::size_t result;
97663
97664   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97665   {
97666     try {
97667       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);
97668     } catch (std::out_of_range& e) {
97669       {
97670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97671       };
97672     } catch (std::exception& e) {
97673       {
97674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97675       };
97676     } catch (Dali::DaliException e) {
97677       {
97678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97679       };
97680     } catch (...) {
97681       {
97682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97683       };
97684     }
97685   }
97686
97687   jresult = (unsigned long)result;
97688   return jresult;
97689 }
97690
97691
97692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97693   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97694   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97695
97696   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97697   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97698   {
97699     try {
97700       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97701     } catch (std::out_of_range& e) {
97702       {
97703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97704       };
97705     } catch (std::exception& e) {
97706       {
97707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97708       };
97709     } catch (Dali::DaliException e) {
97710       {
97711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97712       };
97713     } catch (...) {
97714       {
97715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97716       };
97717     }
97718   }
97719
97720 }
97721
97722
97723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97724   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97725   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97726
97727   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97728   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97729   {
97730     try {
97731       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97732     } catch (std::out_of_range& e) {
97733       {
97734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97735       };
97736     } catch (std::exception& e) {
97737       {
97738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97739       };
97740     } catch (Dali::DaliException e) {
97741       {
97742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97743       };
97744     } catch (...) {
97745       {
97746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97747       };
97748     }
97749   }
97750
97751 }
97752
97753
97754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97755   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97756   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97757
97758   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97759   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97760   if (!arg2) {
97761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97762     return ;
97763   }
97764   {
97765     try {
97766       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97767     } catch (std::out_of_range& e) {
97768       {
97769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97770       };
97771     } catch (std::exception& e) {
97772       {
97773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97774       };
97775     } catch (Dali::DaliException e) {
97776       {
97777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97778       };
97779     } catch (...) {
97780       {
97781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97782       };
97783     }
97784   }
97785
97786 }
97787
97788
97789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97790   void * jresult ;
97791   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97792
97793   {
97794     try {
97795       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97796     } catch (std::out_of_range& e) {
97797       {
97798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97799       };
97800     } catch (std::exception& e) {
97801       {
97802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97803       };
97804     } catch (Dali::DaliException e) {
97805       {
97806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97807       };
97808     } catch (...) {
97809       {
97810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97811       };
97812     }
97813   }
97814
97815   jresult = (void *)result;
97816   return jresult;
97817 }
97818
97819
97820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97821   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97822
97823   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97824   {
97825     try {
97826       delete arg1;
97827     } catch (std::out_of_range& e) {
97828       {
97829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97830       };
97831     } catch (std::exception& e) {
97832       {
97833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97834       };
97835     } catch (Dali::DaliException e) {
97836       {
97837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97838       };
97839     } catch (...) {
97840       {
97841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97842       };
97843     }
97844   }
97845
97846 }
97847
97848
97849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97850   unsigned int jresult ;
97851   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97852   bool result;
97853
97854   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97855   {
97856     try {
97857       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97858     } catch (std::out_of_range& e) {
97859       {
97860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97861       };
97862     } catch (std::exception& e) {
97863       {
97864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97865       };
97866     } catch (Dali::DaliException e) {
97867       {
97868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97869       };
97870     } catch (...) {
97871       {
97872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97873       };
97874     }
97875   }
97876
97877   jresult = result;
97878   return jresult;
97879 }
97880
97881
97882 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97883   unsigned long jresult ;
97884   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97885   std::size_t result;
97886
97887   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97888   {
97889     try {
97890       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97891     } catch (std::out_of_range& e) {
97892       {
97893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97894       };
97895     } catch (std::exception& e) {
97896       {
97897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97898       };
97899     } catch (Dali::DaliException e) {
97900       {
97901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97902       };
97903     } catch (...) {
97904       {
97905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97906       };
97907     }
97908   }
97909
97910   jresult = (unsigned long)result;
97911   return jresult;
97912 }
97913
97914
97915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97916   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97917   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97918
97919   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97920   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97921   {
97922     try {
97923       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97924     } catch (std::out_of_range& e) {
97925       {
97926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97927       };
97928     } catch (std::exception& e) {
97929       {
97930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97931       };
97932     } catch (Dali::DaliException e) {
97933       {
97934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97935       };
97936     } catch (...) {
97937       {
97938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97939       };
97940     }
97941   }
97942
97943 }
97944
97945
97946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97947   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97948   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97949
97950   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97951   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97952   {
97953     try {
97954       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97955     } catch (std::out_of_range& e) {
97956       {
97957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97958       };
97959     } catch (std::exception& e) {
97960       {
97961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97962       };
97963     } catch (Dali::DaliException e) {
97964       {
97965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97966       };
97967     } catch (...) {
97968       {
97969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97970       };
97971     }
97972   }
97973
97974 }
97975
97976
97977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97978   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97979   Dali::Vector2 *arg2 = 0 ;
97980
97981   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97982   arg2 = (Dali::Vector2 *)jarg2;
97983   if (!arg2) {
97984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97985     return ;
97986   }
97987   {
97988     try {
97989       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97990     } catch (std::out_of_range& e) {
97991       {
97992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97993       };
97994     } catch (std::exception& e) {
97995       {
97996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97997       };
97998     } catch (Dali::DaliException e) {
97999       {
98000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98001       };
98002     } catch (...) {
98003       {
98004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98005       };
98006     }
98007   }
98008
98009 }
98010
98011
98012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98013   void * jresult ;
98014   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98015
98016   {
98017     try {
98018       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98019     } catch (std::out_of_range& e) {
98020       {
98021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98022       };
98023     } catch (std::exception& e) {
98024       {
98025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98026       };
98027     } catch (Dali::DaliException e) {
98028       {
98029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98030       };
98031     } catch (...) {
98032       {
98033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98034       };
98035     }
98036   }
98037
98038   jresult = (void *)result;
98039   return jresult;
98040 }
98041
98042
98043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98044   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98045
98046   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98047   {
98048     try {
98049       delete arg1;
98050     } catch (std::out_of_range& e) {
98051       {
98052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98053       };
98054     } catch (std::exception& e) {
98055       {
98056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98057       };
98058     } catch (Dali::DaliException e) {
98059       {
98060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98061       };
98062     } catch (...) {
98063       {
98064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98065       };
98066     }
98067   }
98068
98069 }
98070
98071
98072
98073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98074   unsigned int jresult ;
98075   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98076   bool result;
98077
98078   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98079   {
98080     try {
98081       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);
98082     } catch (std::out_of_range& e) {
98083       {
98084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98085       };
98086     } catch (std::exception& e) {
98087       {
98088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98089       };
98090     } catch (Dali::DaliException e) {
98091       {
98092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98093       };
98094     } catch (...) {
98095       {
98096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98097       };
98098     }
98099   }
98100
98101   jresult = result;
98102   return jresult;
98103 }
98104
98105
98106 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98107   unsigned long jresult ;
98108   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98109   std::size_t result;
98110
98111   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98112   {
98113     try {
98114       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);
98115     } catch (std::out_of_range& e) {
98116       {
98117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98118       };
98119     } catch (std::exception& e) {
98120       {
98121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98122       };
98123     } catch (Dali::DaliException e) {
98124       {
98125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98126       };
98127     } catch (...) {
98128       {
98129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98130       };
98131     }
98132   }
98133
98134   jresult = (unsigned long)result;
98135   return jresult;
98136 }
98137
98138
98139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98140   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98141   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98142
98143   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98144   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98145   {
98146     try {
98147       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98148     } catch (std::out_of_range& e) {
98149       {
98150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98151       };
98152     } catch (std::exception& e) {
98153       {
98154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98155       };
98156     } catch (Dali::DaliException e) {
98157       {
98158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98159       };
98160     } catch (...) {
98161       {
98162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98163       };
98164     }
98165   }
98166
98167 }
98168
98169
98170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98171   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98172   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98173
98174   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98175   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98176   {
98177     try {
98178       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98179     } catch (std::out_of_range& e) {
98180       {
98181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98182       };
98183     } catch (std::exception& e) {
98184       {
98185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98186       };
98187     } catch (Dali::DaliException e) {
98188       {
98189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98190       };
98191     } catch (...) {
98192       {
98193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98194       };
98195     }
98196   }
98197
98198 }
98199
98200
98201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98202   unsigned int jresult ;
98203   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98204   Dali::Toolkit::Control arg2 ;
98205   Dali::KeyEvent *arg3 = 0 ;
98206   Dali::Toolkit::Control *argp2 ;
98207   bool result;
98208
98209   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98210   argp2 = (Dali::Toolkit::Control *)jarg2;
98211   if (!argp2) {
98212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98213     return 0;
98214   }
98215   arg2 = *argp2;
98216   arg3 = (Dali::KeyEvent *)jarg3;
98217   if (!arg3) {
98218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98219     return 0;
98220   }
98221   {
98222     try {
98223       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);
98224     } catch (std::out_of_range& e) {
98225       {
98226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98227       };
98228     } catch (std::exception& e) {
98229       {
98230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98231       };
98232     } catch (Dali::DaliException e) {
98233       {
98234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98235       };
98236     } catch (...) {
98237       {
98238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98239       };
98240     }
98241   }
98242
98243   jresult = result;
98244   return jresult;
98245 }
98246
98247
98248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98249   void * jresult ;
98250   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98251
98252   {
98253     try {
98254       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98255     } catch (std::out_of_range& e) {
98256       {
98257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98258       };
98259     } catch (std::exception& e) {
98260       {
98261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98262       };
98263     } catch (Dali::DaliException e) {
98264       {
98265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98266       };
98267     } catch (...) {
98268       {
98269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98270       };
98271     }
98272   }
98273
98274   jresult = (void *)result;
98275   return jresult;
98276 }
98277
98278
98279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98280   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98281
98282   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98283   {
98284     try {
98285       delete arg1;
98286     } catch (std::out_of_range& e) {
98287       {
98288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98289       };
98290     } catch (std::exception& e) {
98291       {
98292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98293       };
98294     } catch (Dali::DaliException e) {
98295       {
98296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98297       };
98298     } catch (...) {
98299       {
98300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98301       };
98302     }
98303   }
98304
98305 }
98306
98307
98308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98309   unsigned int jresult ;
98310   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98311   bool result;
98312
98313   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98314   {
98315     try {
98316       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98317     } catch (std::out_of_range& e) {
98318       {
98319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98320       };
98321     } catch (std::exception& e) {
98322       {
98323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98324       };
98325     } catch (Dali::DaliException e) {
98326       {
98327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98328       };
98329     } catch (...) {
98330       {
98331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98332       };
98333     }
98334   }
98335
98336   jresult = result;
98337   return jresult;
98338 }
98339
98340
98341 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98342   unsigned long jresult ;
98343   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98344   std::size_t result;
98345
98346   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98347   {
98348     try {
98349       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98350     } catch (std::out_of_range& e) {
98351       {
98352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98353       };
98354     } catch (std::exception& e) {
98355       {
98356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98357       };
98358     } catch (Dali::DaliException e) {
98359       {
98360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98361       };
98362     } catch (...) {
98363       {
98364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98365       };
98366     }
98367   }
98368
98369   jresult = (unsigned long)result;
98370   return jresult;
98371 }
98372
98373
98374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98375   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98376   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98377
98378   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98379   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98380   {
98381     try {
98382       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98383     } catch (std::out_of_range& e) {
98384       {
98385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98386       };
98387     } catch (std::exception& e) {
98388       {
98389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98390       };
98391     } catch (Dali::DaliException e) {
98392       {
98393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98394       };
98395     } catch (...) {
98396       {
98397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98398       };
98399     }
98400   }
98401
98402 }
98403
98404
98405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98406   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98407   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98408
98409   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98410   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98411   {
98412     try {
98413       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98414     } catch (std::out_of_range& e) {
98415       {
98416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98417       };
98418     } catch (std::exception& e) {
98419       {
98420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98421       };
98422     } catch (Dali::DaliException e) {
98423       {
98424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98425       };
98426     } catch (...) {
98427       {
98428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98429       };
98430     }
98431   }
98432
98433 }
98434
98435
98436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98437   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98438   Dali::Toolkit::Control arg2 ;
98439   Dali::Toolkit::Control *argp2 ;
98440
98441   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98442   argp2 = (Dali::Toolkit::Control *)jarg2;
98443   if (!argp2) {
98444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98445     return ;
98446   }
98447   arg2 = *argp2;
98448   {
98449     try {
98450       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98451     } catch (std::out_of_range& e) {
98452       {
98453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98454       };
98455     } catch (std::exception& e) {
98456       {
98457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98458       };
98459     } catch (Dali::DaliException e) {
98460       {
98461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98462       };
98463     } catch (...) {
98464       {
98465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98466       };
98467     }
98468   }
98469
98470 }
98471
98472
98473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98474   void * jresult ;
98475   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98476
98477   {
98478     try {
98479       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98480     } catch (std::out_of_range& e) {
98481       {
98482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98483       };
98484     } catch (std::exception& e) {
98485       {
98486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98487       };
98488     } catch (Dali::DaliException e) {
98489       {
98490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98491       };
98492     } catch (...) {
98493       {
98494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98495       };
98496     }
98497   }
98498
98499   jresult = (void *)result;
98500   return jresult;
98501 }
98502
98503
98504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98505   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98506
98507   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98508   {
98509     try {
98510       delete arg1;
98511     } catch (std::out_of_range& e) {
98512       {
98513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98514       };
98515     } catch (std::exception& e) {
98516       {
98517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98518       };
98519     } catch (Dali::DaliException e) {
98520       {
98521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98522       };
98523     } catch (...) {
98524       {
98525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98526       };
98527     }
98528   }
98529
98530 }
98531
98532
98533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98534   unsigned int jresult ;
98535   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98536   bool result;
98537
98538   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98539   {
98540     try {
98541       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98542     } catch (std::out_of_range& e) {
98543       {
98544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98545       };
98546     } catch (std::exception& e) {
98547       {
98548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98549       };
98550     } catch (Dali::DaliException e) {
98551       {
98552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98553       };
98554     } catch (...) {
98555       {
98556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98557       };
98558     }
98559   }
98560
98561   jresult = result;
98562   return jresult;
98563 }
98564
98565
98566 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98567   unsigned long jresult ;
98568   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98569   std::size_t result;
98570
98571   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98572   {
98573     try {
98574       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98575     } catch (std::out_of_range& e) {
98576       {
98577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98578       };
98579     } catch (std::exception& e) {
98580       {
98581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98582       };
98583     } catch (Dali::DaliException e) {
98584       {
98585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98586       };
98587     } catch (...) {
98588       {
98589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98590       };
98591     }
98592   }
98593
98594   jresult = (unsigned long)result;
98595   return jresult;
98596 }
98597
98598
98599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98600   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98601   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98602
98603   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98604   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98605   {
98606     try {
98607       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98608     } catch (std::out_of_range& e) {
98609       {
98610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98611       };
98612     } catch (std::exception& e) {
98613       {
98614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98615       };
98616     } catch (Dali::DaliException e) {
98617       {
98618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98619       };
98620     } catch (...) {
98621       {
98622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98623       };
98624     }
98625   }
98626
98627 }
98628
98629
98630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98631   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98632   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98633
98634   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98635   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98636   {
98637     try {
98638       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98639     } catch (std::out_of_range& e) {
98640       {
98641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98642       };
98643     } catch (std::exception& e) {
98644       {
98645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98646       };
98647     } catch (Dali::DaliException e) {
98648       {
98649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98650       };
98651     } catch (...) {
98652       {
98653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98654       };
98655     }
98656   }
98657
98658 }
98659
98660
98661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98662   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98663   Dali::Toolkit::VideoView *arg2 = 0 ;
98664
98665   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98666   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98667   if (!arg2) {
98668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98669     return ;
98670   }
98671   {
98672     try {
98673       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98674     } catch (std::out_of_range& e) {
98675       {
98676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98677       };
98678     } catch (std::exception& e) {
98679       {
98680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98681       };
98682     } catch (Dali::DaliException e) {
98683       {
98684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98685       };
98686     } catch (...) {
98687       {
98688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98689       };
98690     }
98691   }
98692
98693 }
98694
98695
98696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98697   void * jresult ;
98698   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98699
98700   {
98701     try {
98702       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98703     } catch (std::out_of_range& e) {
98704       {
98705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98706       };
98707     } catch (std::exception& e) {
98708       {
98709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98710       };
98711     } catch (Dali::DaliException e) {
98712       {
98713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98714       };
98715     } catch (...) {
98716       {
98717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98718       };
98719     }
98720   }
98721
98722   jresult = (void *)result;
98723   return jresult;
98724 }
98725
98726
98727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98728   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98729
98730   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98731   {
98732     try {
98733       delete arg1;
98734     } catch (std::out_of_range& e) {
98735       {
98736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98737       };
98738     } catch (std::exception& e) {
98739       {
98740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98741       };
98742     } catch (Dali::DaliException e) {
98743       {
98744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98745       };
98746     } catch (...) {
98747       {
98748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98749       };
98750     }
98751   }
98752
98753 }
98754
98755
98756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98757   unsigned int jresult ;
98758   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98759   bool result;
98760
98761   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98762   {
98763     try {
98764       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98765     } catch (std::out_of_range& e) {
98766       {
98767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98768       };
98769     } catch (std::exception& e) {
98770       {
98771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98772       };
98773     } catch (Dali::DaliException e) {
98774       {
98775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98776       };
98777     } catch (...) {
98778       {
98779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98780       };
98781     }
98782   }
98783
98784   jresult = result;
98785   return jresult;
98786 }
98787
98788
98789 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98790   unsigned long jresult ;
98791   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98792   std::size_t result;
98793
98794   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98795   {
98796     try {
98797       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98798     } catch (std::out_of_range& e) {
98799       {
98800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98801       };
98802     } catch (std::exception& e) {
98803       {
98804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98805       };
98806     } catch (Dali::DaliException e) {
98807       {
98808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98809       };
98810     } catch (...) {
98811       {
98812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98813       };
98814     }
98815   }
98816
98817   jresult = (unsigned long)result;
98818   return jresult;
98819 }
98820
98821
98822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98823   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98824   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98825
98826   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98827   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98828   {
98829     try {
98830       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98831     } catch (std::out_of_range& e) {
98832       {
98833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98834       };
98835     } catch (std::exception& e) {
98836       {
98837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98838       };
98839     } catch (Dali::DaliException e) {
98840       {
98841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98842       };
98843     } catch (...) {
98844       {
98845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98846       };
98847     }
98848   }
98849
98850 }
98851
98852
98853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98854   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98855   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98856
98857   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98858   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98859   {
98860     try {
98861       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98862     } catch (std::out_of_range& e) {
98863       {
98864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98865       };
98866     } catch (std::exception& e) {
98867       {
98868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98869       };
98870     } catch (Dali::DaliException e) {
98871       {
98872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98873       };
98874     } catch (...) {
98875       {
98876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98877       };
98878     }
98879   }
98880
98881 }
98882
98883
98884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98885   unsigned int jresult ;
98886   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98887   Dali::Toolkit::Slider arg2 ;
98888   float arg3 ;
98889   Dali::Toolkit::Slider *argp2 ;
98890   bool result;
98891
98892   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98893   argp2 = (Dali::Toolkit::Slider *)jarg2;
98894   if (!argp2) {
98895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98896     return 0;
98897   }
98898   arg2 = *argp2;
98899   arg3 = (float)jarg3;
98900   {
98901     try {
98902       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98903     } catch (std::out_of_range& e) {
98904       {
98905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98906       };
98907     } catch (std::exception& e) {
98908       {
98909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98910       };
98911     } catch (Dali::DaliException e) {
98912       {
98913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98914       };
98915     } catch (...) {
98916       {
98917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98918       };
98919     }
98920   }
98921
98922   jresult = result;
98923   return jresult;
98924 }
98925
98926
98927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98928   void * jresult ;
98929   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98930
98931   {
98932     try {
98933       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98934     } catch (std::out_of_range& e) {
98935       {
98936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98937       };
98938     } catch (std::exception& e) {
98939       {
98940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98941       };
98942     } catch (Dali::DaliException e) {
98943       {
98944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98945       };
98946     } catch (...) {
98947       {
98948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98949       };
98950     }
98951   }
98952
98953   jresult = (void *)result;
98954   return jresult;
98955 }
98956
98957
98958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98959   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98960
98961   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98962   {
98963     try {
98964       delete arg1;
98965     } catch (std::out_of_range& e) {
98966       {
98967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98968       };
98969     } catch (std::exception& e) {
98970       {
98971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98972       };
98973     } catch (Dali::DaliException e) {
98974       {
98975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98976       };
98977     } catch (...) {
98978       {
98979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98980       };
98981     }
98982   }
98983
98984 }
98985
98986
98987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98988   unsigned int jresult ;
98989   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98990   bool result;
98991
98992   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98993   {
98994     try {
98995       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98996     } catch (std::out_of_range& e) {
98997       {
98998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98999       };
99000     } catch (std::exception& e) {
99001       {
99002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99003       };
99004     } catch (Dali::DaliException e) {
99005       {
99006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99007       };
99008     } catch (...) {
99009       {
99010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99011       };
99012     }
99013   }
99014
99015   jresult = result;
99016   return jresult;
99017 }
99018
99019
99020 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99021   unsigned long jresult ;
99022   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99023   std::size_t result;
99024
99025   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99026   {
99027     try {
99028       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99029     } catch (std::out_of_range& e) {
99030       {
99031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99032       };
99033     } catch (std::exception& e) {
99034       {
99035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99036       };
99037     } catch (Dali::DaliException e) {
99038       {
99039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99040       };
99041     } catch (...) {
99042       {
99043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99044       };
99045     }
99046   }
99047
99048   jresult = (unsigned long)result;
99049   return jresult;
99050 }
99051
99052
99053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99054   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99055   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99056
99057   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99058   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99059   {
99060     try {
99061       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99062     } catch (std::out_of_range& e) {
99063       {
99064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99065       };
99066     } catch (std::exception& e) {
99067       {
99068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99069       };
99070     } catch (Dali::DaliException e) {
99071       {
99072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99073       };
99074     } catch (...) {
99075       {
99076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99077       };
99078     }
99079   }
99080
99081 }
99082
99083
99084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99085   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99086   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99087
99088   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99089   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99090   {
99091     try {
99092       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99093     } catch (std::out_of_range& e) {
99094       {
99095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99096       };
99097     } catch (std::exception& e) {
99098       {
99099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99100       };
99101     } catch (Dali::DaliException e) {
99102       {
99103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99104       };
99105     } catch (...) {
99106       {
99107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99108       };
99109     }
99110   }
99111
99112 }
99113
99114
99115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99116   unsigned int jresult ;
99117   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99118   Dali::Toolkit::Slider arg2 ;
99119   int arg3 ;
99120   Dali::Toolkit::Slider *argp2 ;
99121   bool result;
99122
99123   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99124   argp2 = (Dali::Toolkit::Slider *)jarg2;
99125   if (!argp2) {
99126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99127     return 0;
99128   }
99129   arg2 = *argp2;
99130   arg3 = (int)jarg3;
99131   {
99132     try {
99133       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99134     } catch (std::out_of_range& e) {
99135       {
99136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99137       };
99138     } catch (std::exception& e) {
99139       {
99140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99141       };
99142     } catch (Dali::DaliException e) {
99143       {
99144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99145       };
99146     } catch (...) {
99147       {
99148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99149       };
99150     }
99151   }
99152
99153   jresult = result;
99154   return jresult;
99155 }
99156
99157
99158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99159   void * jresult ;
99160   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99161
99162   {
99163     try {
99164       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99165     } catch (std::out_of_range& e) {
99166       {
99167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99168       };
99169     } catch (std::exception& e) {
99170       {
99171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99172       };
99173     } catch (Dali::DaliException e) {
99174       {
99175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99176       };
99177     } catch (...) {
99178       {
99179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99180       };
99181     }
99182   }
99183
99184   jresult = (void *)result;
99185   return jresult;
99186 }
99187
99188
99189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99190   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99191
99192   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99193   {
99194     try {
99195       delete arg1;
99196     } catch (std::out_of_range& e) {
99197       {
99198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99199       };
99200     } catch (std::exception& e) {
99201       {
99202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99203       };
99204     } catch (Dali::DaliException e) {
99205       {
99206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99207       };
99208     } catch (...) {
99209       {
99210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99211       };
99212     }
99213   }
99214
99215 }
99216
99217
99218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99219   void * jresult ;
99220   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99221
99222   {
99223     try {
99224       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99225     } catch (std::out_of_range& e) {
99226       {
99227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99228       };
99229     } catch (std::exception& e) {
99230       {
99231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99232       };
99233     } catch (Dali::DaliException e) {
99234       {
99235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99236       };
99237     } catch (...) {
99238       {
99239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99240       };
99241     }
99242   }
99243
99244   jresult = (void *)result;
99245   return jresult;
99246 }
99247
99248
99249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99250   void * jresult ;
99251   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99252   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99253
99254   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99255   {
99256     try {
99257       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99258     } catch (std::out_of_range& e) {
99259       {
99260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99261       };
99262     } catch (std::exception& e) {
99263       {
99264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99265       };
99266     } catch (Dali::DaliException e) {
99267       {
99268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99269       };
99270     } catch (...) {
99271       {
99272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99273       };
99274     }
99275   }
99276
99277   jresult = (void *)result;
99278   return jresult;
99279 }
99280
99281
99282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99283   void * jresult ;
99284   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99285   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99286
99287   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99288   if (!arg1) {
99289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99290     return 0;
99291   }
99292   {
99293     try {
99294       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99295     } catch (std::out_of_range& e) {
99296       {
99297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99298       };
99299     } catch (std::exception& e) {
99300       {
99301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99302       };
99303     } catch (Dali::DaliException e) {
99304       {
99305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99306       };
99307     } catch (...) {
99308       {
99309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99310       };
99311     }
99312   }
99313
99314   jresult = (void *)result;
99315   return jresult;
99316 }
99317
99318
99319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99320   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99321
99322   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99323   {
99324     try {
99325       delete arg1;
99326     } catch (std::out_of_range& e) {
99327       {
99328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99329       };
99330     } catch (std::exception& e) {
99331       {
99332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99333       };
99334     } catch (Dali::DaliException e) {
99335       {
99336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99337       };
99338     } catch (...) {
99339       {
99340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99341       };
99342     }
99343   }
99344
99345 }
99346
99347
99348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99349   void * jresult ;
99350   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99351   Dali::Toolkit::Ruler *result = 0 ;
99352
99353   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99354   {
99355     try {
99356       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99357     } catch (std::out_of_range& e) {
99358       {
99359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99360       };
99361     } catch (std::exception& e) {
99362       {
99363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99364       };
99365     } catch (Dali::DaliException e) {
99366       {
99367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99368       };
99369     } catch (...) {
99370       {
99371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99372       };
99373     }
99374   }
99375
99376   jresult = (void *)result;
99377   return jresult;
99378 }
99379
99380
99381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99382   void * jresult ;
99383   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99384   Dali::Toolkit::Ruler *result = 0 ;
99385
99386   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99387   {
99388     try {
99389       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99390     } catch (std::out_of_range& e) {
99391       {
99392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99393       };
99394     } catch (std::exception& e) {
99395       {
99396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99397       };
99398     } catch (Dali::DaliException e) {
99399       {
99400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99401       };
99402     } catch (...) {
99403       {
99404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99405       };
99406     }
99407   }
99408
99409   jresult = (void *)result;
99410   return jresult;
99411 }
99412
99413
99414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99415   void * jresult ;
99416   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99417   Dali::Toolkit::Ruler *result = 0 ;
99418
99419   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99420   {
99421     try {
99422       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99423     } catch (std::out_of_range& e) {
99424       {
99425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99426       };
99427     } catch (std::exception& e) {
99428       {
99429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99430       };
99431     } catch (Dali::DaliException e) {
99432       {
99433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99434       };
99435     } catch (...) {
99436       {
99437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99438       };
99439     }
99440   }
99441
99442   jresult = (void *)result;
99443   return jresult;
99444 }
99445
99446
99447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99448   void * jresult ;
99449   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99450   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99451   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99452
99453   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99454   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99455   if (!arg2) {
99456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99457     return 0;
99458   }
99459   {
99460     try {
99461       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99462     } catch (std::out_of_range& e) {
99463       {
99464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99465       };
99466     } catch (std::exception& e) {
99467       {
99468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99469       };
99470     } catch (Dali::DaliException e) {
99471       {
99472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99473       };
99474     } catch (...) {
99475       {
99476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99477       };
99478     }
99479   }
99480
99481   jresult = (void *)result;
99482   return jresult;
99483 }
99484
99485
99486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99487   void * jresult ;
99488   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99489   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99490   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99491
99492   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99493   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99494   {
99495     try {
99496       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99497     } catch (std::out_of_range& e) {
99498       {
99499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99500       };
99501     } catch (std::exception& e) {
99502       {
99503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99504       };
99505     } catch (Dali::DaliException e) {
99506       {
99507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99508       };
99509     } catch (...) {
99510       {
99511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99512       };
99513     }
99514   }
99515
99516   jresult = (void *)result;
99517   return jresult;
99518 }
99519
99520
99521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99522   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99523
99524   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99525   {
99526     try {
99527       (arg1)->Reset();
99528     } catch (std::out_of_range& e) {
99529       {
99530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99531       };
99532     } catch (std::exception& e) {
99533       {
99534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99535       };
99536     } catch (Dali::DaliException e) {
99537       {
99538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99539       };
99540     } catch (...) {
99541       {
99542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99543       };
99544     }
99545   }
99546
99547 }
99548
99549
99550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99551   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99552   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99553
99554   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99555   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99556   {
99557     try {
99558       (arg1)->Reset(arg2);
99559     } catch (std::out_of_range& e) {
99560       {
99561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99562       };
99563     } catch (std::exception& e) {
99564       {
99565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99566       };
99567     } catch (Dali::DaliException e) {
99568       {
99569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99570       };
99571     } catch (...) {
99572       {
99573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99574       };
99575     }
99576   }
99577
99578 }
99579
99580
99581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99582   void * jresult ;
99583   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99584   Dali::Toolkit::Ruler *result = 0 ;
99585
99586   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99587   {
99588     try {
99589       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99590     } catch (std::out_of_range& e) {
99591       {
99592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99593       };
99594     } catch (std::exception& e) {
99595       {
99596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99597       };
99598     } catch (Dali::DaliException e) {
99599       {
99600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99601       };
99602     } catch (...) {
99603       {
99604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99605       };
99606     }
99607   }
99608
99609   jresult = (void *)result;
99610   return jresult;
99611 }
99612
99613
99614 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99615   float jresult ;
99616   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99617   float arg2 ;
99618   float arg3 ;
99619   float result;
99620
99621   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99622   arg2 = (float)jarg2;
99623   arg3 = (float)jarg3;
99624   {
99625     try {
99626       result = (float)(*arg1)->Snap(arg2,arg3);
99627     } catch (std::out_of_range& e) {
99628       {
99629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99630       };
99631     } catch (std::exception& e) {
99632       {
99633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99634       };
99635     } catch (Dali::DaliException e) {
99636       {
99637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99638       };
99639     } catch (...) {
99640       {
99641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99642       };
99643     }
99644   }
99645
99646   jresult = result;
99647   return jresult;
99648 }
99649
99650
99651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99652   float jresult ;
99653   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99654   float arg2 ;
99655   float result;
99656
99657   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99658   arg2 = (float)jarg2;
99659   {
99660     try {
99661       result = (float)(*arg1)->Snap(arg2);
99662     } catch (std::out_of_range& e) {
99663       {
99664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99665       };
99666     } catch (std::exception& e) {
99667       {
99668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99669       };
99670     } catch (Dali::DaliException e) {
99671       {
99672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99673       };
99674     } catch (...) {
99675       {
99676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99677       };
99678     }
99679   }
99680
99681   jresult = result;
99682   return jresult;
99683 }
99684
99685
99686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99687   float jresult ;
99688   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99689   unsigned int arg2 ;
99690   unsigned int *arg3 = 0 ;
99691   bool arg4 ;
99692   float result;
99693
99694   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99695   arg2 = (unsigned int)jarg2;
99696   arg3 = (unsigned int *)jarg3;
99697   arg4 = jarg4 ? true : false;
99698   {
99699     try {
99700       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99701     } catch (std::out_of_range& e) {
99702       {
99703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99704       };
99705     } catch (std::exception& e) {
99706       {
99707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99708       };
99709     } catch (Dali::DaliException e) {
99710       {
99711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99712       };
99713     } catch (...) {
99714       {
99715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99716       };
99717     }
99718   }
99719
99720   jresult = result;
99721   return jresult;
99722 }
99723
99724
99725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99726   unsigned int jresult ;
99727   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99728   float arg2 ;
99729   bool arg3 ;
99730   unsigned int result;
99731
99732   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99733   arg2 = (float)jarg2;
99734   arg3 = jarg3 ? true : false;
99735   {
99736     try {
99737       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99738     } catch (std::out_of_range& e) {
99739       {
99740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99741       };
99742     } catch (std::exception& e) {
99743       {
99744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99745       };
99746     } catch (Dali::DaliException e) {
99747       {
99748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99749       };
99750     } catch (...) {
99751       {
99752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99753       };
99754     }
99755   }
99756
99757   jresult = result;
99758   return jresult;
99759 }
99760
99761
99762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99763   unsigned int jresult ;
99764   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99765   unsigned int result;
99766
99767   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99768   {
99769     try {
99770       result = (unsigned int)(*arg1)->GetTotalPages();
99771     } catch (std::out_of_range& e) {
99772       {
99773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99774       };
99775     } catch (std::exception& e) {
99776       {
99777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99778       };
99779     } catch (Dali::DaliException e) {
99780       {
99781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99782       };
99783     } catch (...) {
99784       {
99785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99786       };
99787     }
99788   }
99789
99790   jresult = result;
99791   return jresult;
99792 }
99793
99794
99795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99796   int jresult ;
99797   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99798   Dali::Toolkit::Ruler::RulerType result;
99799
99800   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99801   {
99802     try {
99803       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99804     } catch (std::out_of_range& e) {
99805       {
99806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99807       };
99808     } catch (std::exception& e) {
99809       {
99810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99811       };
99812     } catch (Dali::DaliException e) {
99813       {
99814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99815       };
99816     } catch (...) {
99817       {
99818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99819       };
99820     }
99821   }
99822
99823   jresult = (int)result;
99824   return jresult;
99825 }
99826
99827
99828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99829   unsigned int jresult ;
99830   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99831   bool result;
99832
99833   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99834   {
99835     try {
99836       result = (bool)(*arg1)->IsEnabled();
99837     } catch (std::out_of_range& e) {
99838       {
99839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99840       };
99841     } catch (std::exception& e) {
99842       {
99843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99844       };
99845     } catch (Dali::DaliException e) {
99846       {
99847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99848       };
99849     } catch (...) {
99850       {
99851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99852       };
99853     }
99854   }
99855
99856   jresult = result;
99857   return jresult;
99858 }
99859
99860
99861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99862   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99863
99864   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99865   {
99866     try {
99867       (*arg1)->Enable();
99868     } catch (std::out_of_range& e) {
99869       {
99870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99871       };
99872     } catch (std::exception& e) {
99873       {
99874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99875       };
99876     } catch (Dali::DaliException e) {
99877       {
99878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99879       };
99880     } catch (...) {
99881       {
99882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99883       };
99884     }
99885   }
99886
99887 }
99888
99889
99890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99891   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99892
99893   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99894   {
99895     try {
99896       (*arg1)->Disable();
99897     } catch (std::out_of_range& e) {
99898       {
99899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99900       };
99901     } catch (std::exception& e) {
99902       {
99903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99904       };
99905     } catch (Dali::DaliException e) {
99906       {
99907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99908       };
99909     } catch (...) {
99910       {
99911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99912       };
99913     }
99914   }
99915
99916 }
99917
99918
99919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99920   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99921   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99922   Dali::Toolkit::RulerDomain *argp2 ;
99923
99924   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99925   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99926   if (!argp2) {
99927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99928     return ;
99929   }
99930   arg2 = *argp2;
99931   {
99932     try {
99933       (*arg1)->SetDomain(arg2);
99934     } catch (std::out_of_range& e) {
99935       {
99936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99937       };
99938     } catch (std::exception& e) {
99939       {
99940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99941       };
99942     } catch (Dali::DaliException e) {
99943       {
99944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99945       };
99946     } catch (...) {
99947       {
99948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99949       };
99950     }
99951   }
99952
99953 }
99954
99955
99956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99957   void * jresult ;
99958   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99959   Dali::Toolkit::RulerDomain *result = 0 ;
99960
99961   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99962   {
99963     try {
99964       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99965     } catch (std::out_of_range& e) {
99966       {
99967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99968       };
99969     } catch (std::exception& e) {
99970       {
99971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99972       };
99973     } catch (Dali::DaliException e) {
99974       {
99975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99976       };
99977     } catch (...) {
99978       {
99979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99980       };
99981     }
99982   }
99983
99984   jresult = (void *)result;
99985   return jresult;
99986 }
99987
99988
99989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99990   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99991
99992   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99993   {
99994     try {
99995       (*arg1)->DisableDomain();
99996     } catch (std::out_of_range& e) {
99997       {
99998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99999       };
100000     } catch (std::exception& e) {
100001       {
100002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100003       };
100004     } catch (Dali::DaliException e) {
100005       {
100006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100007       };
100008     } catch (...) {
100009       {
100010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100011       };
100012     }
100013   }
100014
100015 }
100016
100017
100018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100019   float jresult ;
100020   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100021   float arg2 ;
100022   float arg3 ;
100023   float arg4 ;
100024   float result;
100025
100026   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100027   arg2 = (float)jarg2;
100028   arg3 = (float)jarg3;
100029   arg4 = (float)jarg4;
100030   {
100031     try {
100032       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100033     } catch (std::out_of_range& e) {
100034       {
100035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100036       };
100037     } catch (std::exception& e) {
100038       {
100039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100040       };
100041     } catch (Dali::DaliException e) {
100042       {
100043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100044       };
100045     } catch (...) {
100046       {
100047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100048       };
100049     }
100050   }
100051
100052   jresult = result;
100053   return jresult;
100054 }
100055
100056
100057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100058   float jresult ;
100059   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100060   float arg2 ;
100061   float arg3 ;
100062   float result;
100063
100064   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100065   arg2 = (float)jarg2;
100066   arg3 = (float)jarg3;
100067   {
100068     try {
100069       result = (float)(*arg1)->Clamp(arg2,arg3);
100070     } catch (std::out_of_range& e) {
100071       {
100072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100073       };
100074     } catch (std::exception& e) {
100075       {
100076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100077       };
100078     } catch (Dali::DaliException e) {
100079       {
100080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100081       };
100082     } catch (...) {
100083       {
100084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100085       };
100086     }
100087   }
100088
100089   jresult = result;
100090   return jresult;
100091 }
100092
100093
100094 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100095   float jresult ;
100096   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100097   float arg2 ;
100098   float result;
100099
100100   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100101   arg2 = (float)jarg2;
100102   {
100103     try {
100104       result = (float)(*arg1)->Clamp(arg2);
100105     } catch (std::out_of_range& e) {
100106       {
100107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100108       };
100109     } catch (std::exception& e) {
100110       {
100111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100112       };
100113     } catch (Dali::DaliException e) {
100114       {
100115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100116       };
100117     } catch (...) {
100118       {
100119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100120       };
100121     }
100122   }
100123
100124   jresult = result;
100125   return jresult;
100126 }
100127
100128
100129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100130   float jresult ;
100131   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100132   float arg2 ;
100133   float arg3 ;
100134   float arg4 ;
100135   Dali::Toolkit::ClampState *arg5 = 0 ;
100136   float result;
100137
100138   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100139   arg2 = (float)jarg2;
100140   arg3 = (float)jarg3;
100141   arg4 = (float)jarg4;
100142   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100143   if (!arg5) {
100144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100145     return 0;
100146   }
100147   {
100148     try {
100149       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100150     } catch (std::out_of_range& e) {
100151       {
100152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100153       };
100154     } catch (std::exception& e) {
100155       {
100156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100157       };
100158     } catch (Dali::DaliException e) {
100159       {
100160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100161       };
100162     } catch (...) {
100163       {
100164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100165       };
100166     }
100167   }
100168
100169   jresult = result;
100170   return jresult;
100171 }
100172
100173
100174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100175   float jresult ;
100176   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100177   float arg2 ;
100178   float arg3 ;
100179   float arg4 ;
100180   float arg5 ;
100181   float result;
100182
100183   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100184   arg2 = (float)jarg2;
100185   arg3 = (float)jarg3;
100186   arg4 = (float)jarg4;
100187   arg5 = (float)jarg5;
100188   {
100189     try {
100190       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100191     } catch (std::out_of_range& e) {
100192       {
100193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100194       };
100195     } catch (std::exception& e) {
100196       {
100197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100198       };
100199     } catch (Dali::DaliException e) {
100200       {
100201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100202       };
100203     } catch (...) {
100204       {
100205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100206       };
100207     }
100208   }
100209
100210   jresult = result;
100211   return jresult;
100212 }
100213
100214
100215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100216   float jresult ;
100217   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100218   float arg2 ;
100219   float arg3 ;
100220   float arg4 ;
100221   float result;
100222
100223   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100224   arg2 = (float)jarg2;
100225   arg3 = (float)jarg3;
100226   arg4 = (float)jarg4;
100227   {
100228     try {
100229       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100230     } catch (std::out_of_range& e) {
100231       {
100232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100233       };
100234     } catch (std::exception& e) {
100235       {
100236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100237       };
100238     } catch (Dali::DaliException e) {
100239       {
100240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100241       };
100242     } catch (...) {
100243       {
100244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100245       };
100246     }
100247   }
100248
100249   jresult = result;
100250   return jresult;
100251 }
100252
100253
100254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100255   float jresult ;
100256   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100257   float arg2 ;
100258   float arg3 ;
100259   float result;
100260
100261   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100262   arg2 = (float)jarg2;
100263   arg3 = (float)jarg3;
100264   {
100265     try {
100266       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100267     } catch (std::out_of_range& e) {
100268       {
100269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100270       };
100271     } catch (std::exception& e) {
100272       {
100273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100274       };
100275     } catch (Dali::DaliException e) {
100276       {
100277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100278       };
100279     } catch (...) {
100280       {
100281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100282       };
100283     }
100284   }
100285
100286   jresult = result;
100287   return jresult;
100288 }
100289
100290
100291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100292   float jresult ;
100293   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100294   float arg2 ;
100295   float result;
100296
100297   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100298   arg2 = (float)jarg2;
100299   {
100300     try {
100301       result = (float)(*arg1)->SnapAndClamp(arg2);
100302     } catch (std::out_of_range& e) {
100303       {
100304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100305       };
100306     } catch (std::exception& e) {
100307       {
100308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100309       };
100310     } catch (Dali::DaliException e) {
100311       {
100312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100313       };
100314     } catch (...) {
100315       {
100316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100317       };
100318     }
100319   }
100320
100321   jresult = result;
100322   return jresult;
100323 }
100324
100325
100326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100327   float jresult ;
100328   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100329   float arg2 ;
100330   float arg3 ;
100331   float arg4 ;
100332   float arg5 ;
100333   Dali::Toolkit::ClampState *arg6 = 0 ;
100334   float result;
100335
100336   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100337   arg2 = (float)jarg2;
100338   arg3 = (float)jarg3;
100339   arg4 = (float)jarg4;
100340   arg5 = (float)jarg5;
100341   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100342   if (!arg6) {
100343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100344     return 0;
100345   }
100346   {
100347     try {
100348       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100349     } catch (std::out_of_range& e) {
100350       {
100351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100352       };
100353     } catch (std::exception& e) {
100354       {
100355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100356       };
100357     } catch (Dali::DaliException e) {
100358       {
100359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100360       };
100361     } catch (...) {
100362       {
100363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100364       };
100365     }
100366   }
100367
100368   jresult = result;
100369   return jresult;
100370 }
100371
100372
100373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100374   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100375
100376   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100377   {
100378     try {
100379       (*arg1)->Reference();
100380     } catch (std::out_of_range& e) {
100381       {
100382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100383       };
100384     } catch (std::exception& e) {
100385       {
100386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100387       };
100388     } catch (Dali::DaliException e) {
100389       {
100390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100391       };
100392     } catch (...) {
100393       {
100394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100395       };
100396     }
100397   }
100398
100399 }
100400
100401
100402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100403   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100404
100405   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100406   {
100407     try {
100408       (*arg1)->Unreference();
100409     } catch (std::out_of_range& e) {
100410       {
100411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100412       };
100413     } catch (std::exception& e) {
100414       {
100415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100416       };
100417     } catch (Dali::DaliException e) {
100418       {
100419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100420       };
100421     } catch (...) {
100422       {
100423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100424       };
100425     }
100426   }
100427
100428 }
100429
100430
100431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100432   int jresult ;
100433   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100434   int result;
100435
100436   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100437   {
100438     try {
100439       result = (int)(*arg1)->ReferenceCount();
100440     } catch (std::out_of_range& e) {
100441       {
100442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100443       };
100444     } catch (std::exception& e) {
100445       {
100446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100447       };
100448     } catch (Dali::DaliException e) {
100449       {
100450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100451       };
100452     } catch (...) {
100453       {
100454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100455       };
100456     }
100457   }
100458
100459   jresult = result;
100460   return jresult;
100461 }
100462
100463
100464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100465   unsigned int jresult ;
100466   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100467   bool result;
100468
100469   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100470   {
100471     try {
100472       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100473     } catch (std::out_of_range& e) {
100474       {
100475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100476       };
100477     } catch (std::exception& e) {
100478       {
100479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100480       };
100481     } catch (Dali::DaliException e) {
100482       {
100483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100484       };
100485     } catch (...) {
100486       {
100487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100488       };
100489     }
100490   }
100491
100492   jresult = result;
100493   return jresult;
100494 }
100495
100496
100497 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100498   unsigned long jresult ;
100499   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100500   std::size_t result;
100501
100502   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100503   {
100504     try {
100505       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100506     } catch (std::out_of_range& e) {
100507       {
100508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100509       };
100510     } catch (std::exception& e) {
100511       {
100512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100513       };
100514     } catch (Dali::DaliException e) {
100515       {
100516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100517       };
100518     } catch (...) {
100519       {
100520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100521       };
100522     }
100523   }
100524
100525   jresult = (unsigned long)result;
100526   return jresult;
100527 }
100528
100529
100530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100531   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100532   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100533
100534   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100535   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100536   {
100537     try {
100538       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100539     } catch (std::out_of_range& e) {
100540       {
100541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100542       };
100543     } catch (std::exception& e) {
100544       {
100545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100546       };
100547     } catch (Dali::DaliException e) {
100548       {
100549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100550       };
100551     } catch (...) {
100552       {
100553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100554       };
100555     }
100556   }
100557
100558 }
100559
100560
100561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100562   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100563   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100564
100565   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100566   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100567   {
100568     try {
100569       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100570     } catch (std::out_of_range& e) {
100571       {
100572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100573       };
100574     } catch (std::exception& e) {
100575       {
100576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100577       };
100578     } catch (Dali::DaliException e) {
100579       {
100580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100581       };
100582     } catch (...) {
100583       {
100584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100585       };
100586     }
100587   }
100588
100589 }
100590
100591
100592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100593   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100594   Dali::Toolkit::Control arg2 ;
100595   Dali::Toolkit::Control *argp2 ;
100596
100597   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100598   argp2 = (Dali::Toolkit::Control *)jarg2;
100599   if (!argp2) {
100600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100601     return ;
100602   }
100603   arg2 = *argp2;
100604   {
100605     try {
100606       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100607     } catch (std::out_of_range& e) {
100608       {
100609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100610       };
100611     } catch (std::exception& e) {
100612       {
100613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100614       };
100615     } catch (Dali::DaliException e) {
100616       {
100617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100618       };
100619     } catch (...) {
100620       {
100621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100622       };
100623     }
100624   }
100625
100626 }
100627
100628
100629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100630   void * jresult ;
100631   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100632
100633   {
100634     try {
100635       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100636     } catch (std::out_of_range& e) {
100637       {
100638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100639       };
100640     } catch (std::exception& e) {
100641       {
100642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100643       };
100644     } catch (Dali::DaliException e) {
100645       {
100646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100647       };
100648     } catch (...) {
100649       {
100650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100651       };
100652     }
100653   }
100654
100655   jresult = (void *)result;
100656   return jresult;
100657 }
100658
100659
100660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100661   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100662
100663   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100664   {
100665     try {
100666       delete arg1;
100667     } catch (std::out_of_range& e) {
100668       {
100669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100670       };
100671     } catch (std::exception& e) {
100672       {
100673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100674       };
100675     } catch (Dali::DaliException e) {
100676       {
100677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100678       };
100679     } catch (...) {
100680       {
100681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100682       };
100683     }
100684   }
100685
100686 }
100687
100688 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100689   Dali::RefObject *result = NULL;
100690
100691   if (arg1)
100692   {
100693     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100694   }
100695   return result;
100696 }
100697
100698 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100699     return (Dali::RefObject *)jarg1;
100700 }
100701
100702 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100703     return (Dali::SignalObserver *)jarg1;
100704 }
100705
100706 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100707     return (Dali::ConnectionTrackerInterface *)jarg1;
100708 }
100709
100710 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100711     return (Dali::BaseHandle *)jarg1;
100712 }
100713
100714 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100715     return (Dali::BaseHandle *)jarg1;
100716 }
100717
100718 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100719     return (Dali::BaseHandle *)jarg1;
100720 }
100721
100722 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100723     return (Dali::BaseHandle *)jarg1;
100724 }
100725
100726 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100727     return (Dali::BaseHandle *)jarg1;
100728 }
100729
100730 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100731     return (Dali::BaseHandle *)jarg1;
100732 }
100733
100734 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100735     return (Dali::BaseHandle *)jarg1;
100736 }
100737
100738 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100739     return (Dali::BaseHandle *)jarg1;
100740 }
100741
100742 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100743     return (Dali::BaseHandle *)jarg1;
100744 }
100745
100746 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100747     return (Dali::BaseHandle *)jarg1;
100748 }
100749
100750 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100751     return (Dali::BaseHandle *)jarg1;
100752 }
100753
100754 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100755     return (Dali::BaseHandle *)jarg1;
100756 }
100757
100758 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100759     return (Dali::BaseHandle *)jarg1;
100760 }
100761
100762 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100763     return (Dali::Handle *)jarg1;
100764 }
100765
100766 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100767     return (Dali::Handle *)jarg1;
100768 }
100769
100770 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100771     return (Dali::BaseHandle *)jarg1;
100772 }
100773
100774 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100775     return (Dali::BaseHandle *)jarg1;
100776 }
100777
100778 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100779     return (Dali::Handle *)jarg1;
100780 }
100781
100782 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100783     return (Dali::BaseHandle *)jarg1;
100784 }
100785
100786 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100787     return (Dali::Handle *)jarg1;
100788 }
100789
100790 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100791     return (Dali::GestureDetector *)jarg1;
100792 }
100793
100794 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100795     return (Dali::Gesture *)jarg1;
100796 }
100797
100798 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100799     return (Dali::Handle *)jarg1;
100800 }
100801
100802 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100803     return (Dali::Actor *)jarg1;
100804 }
100805
100806 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100807     return (Dali::BaseHandle *)jarg1;
100808 }
100809
100810 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100811     return (Dali::RefObject *)jarg1;
100812 }
100813
100814 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100815     return (Dali::Actor *)jarg1;
100816 }
100817
100818 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100819     return (Dali::GestureDetector *)jarg1;
100820 }
100821
100822 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100823     return (Dali::Gesture *)jarg1;
100824 }
100825
100826 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100827     return (Dali::GestureDetector *)jarg1;
100828 }
100829
100830 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100831     return (Dali::Gesture *)jarg1;
100832 }
100833
100834 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100835     return (Dali::GestureDetector *)jarg1;
100836 }
100837
100838 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100839     return (Dali::Gesture *)jarg1;
100840 }
100841
100842 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100843     return (Dali::BaseHandle *)jarg1;
100844 }
100845
100846 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100847     return (Dali::Handle *)jarg1;
100848 }
100849
100850 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100851     return (Dali::Handle *)jarg1;
100852 }
100853
100854 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100855     return (Dali::Handle *)jarg1;
100856 }
100857
100858 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100859     return (Dali::Image *)jarg1;
100860 }
100861
100862 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100863     return (Dali::Image *)jarg1;
100864 }
100865
100866 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100867     return (Dali::Image *)jarg1;
100868 }
100869
100870 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100871     return (Dali::RefObject *)jarg1;
100872 }
100873
100874 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100875     return (Dali::Image *)jarg1;
100876 }
100877
100878 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100879     return (Dali::Image *)jarg1;
100880 }
100881
100882 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100883     return (Dali::ResourceImage *)jarg1;
100884 }
100885
100886 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100887     return (Dali::Actor *)jarg1;
100888 }
100889
100890 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100891     return (Dali::BaseHandle *)jarg1;
100892 }
100893
100894 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
100895     return (Dali::BaseHandle *)jarg1;
100896 }
100897
100898
100899 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100900     return (Dali::BaseHandle *)jarg1;
100901 }
100902
100903 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100904     return (Dali::BaseHandle *)jarg1;
100905 }
100906
100907 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100908     return (Dali::CustomActorImpl *)jarg1;
100909 }
100910
100911 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100912     return (Dali::CustomActor *)jarg1;
100913 }
100914
100915 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100916     return (Dali::BaseHandle *)jarg1;
100917 }
100918
100919 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100920     return (Dali::Toolkit::Control *)jarg1;
100921 }
100922
100923 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100924     return (Dali::Toolkit::Control *)jarg1;
100925 }
100926
100927 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100928     return (Dali::Toolkit::Button *)jarg1;
100929 }
100930
100931 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100932     return (Dali::Toolkit::Button *)jarg1;
100933 }
100934
100935 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100936     return (Dali::Toolkit::Button *)jarg1;
100937 }
100938
100939 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100940     return (Dali::Toolkit::Control *)jarg1;
100941 }
100942
100943 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100944     return (Dali::Toolkit::Control *)jarg1;
100945 }
100946
100947 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100948     return (Dali::Toolkit::Control *)jarg1;
100949 }
100950
100951 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100952     return (Dali::Toolkit::Control *)jarg1;
100953 }
100954
100955 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100956     return (Dali::Toolkit::Control *)jarg1;
100957 }
100958
100959 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100960     return (Dali::RefObject *)jarg1;
100961 }
100962
100963 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100964     return (Dali::Toolkit::Scrollable *)jarg1;
100965 }
100966
100967 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100968     return (Dali::BaseHandle *)jarg1;
100969 }
100970
100971 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100972     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100973 }
100974
100975 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100976     return (Dali::RefObject *)jarg1;
100977 }
100978
100979 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100980     return (Dali::Toolkit::Ruler *)jarg1;
100981 }
100982
100983 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100984     return (Dali::Toolkit::Ruler *)jarg1;
100985 }
100986
100987 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100988     return (Dali::Toolkit::Scrollable *)jarg1;
100989 }
100990
100991 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100992     return (Dali::Toolkit::Control *)jarg1;
100993 }
100994
100995
100996 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
100997     return (Dali::Toolkit::Control *)jarg1;
100998 }
100999
101000 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101001     return (Dali::BaseHandle *)jarg1;
101002 }
101003
101004 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101005     return (Dali::BaseHandle *)jarg1;
101006 }
101007
101008 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101009     return (Dali::Toolkit::Control *)jarg1;
101010 }
101011
101012 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101013     return (Dali::Toolkit::Control *)jarg1;
101014 }
101015
101016 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101017     return (Dali::Toolkit::Control *)jarg1;
101018 }
101019
101020 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101021     return (Dali::Toolkit::Control *)jarg1;
101022 }
101023
101024 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101025     return (Dali::Toolkit::Control *)jarg1;
101026 }
101027
101028 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101029     return (Dali::Toolkit::Control *)jarg1;
101030 }
101031
101032 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101033     return (Dali::Toolkit::PageTurnView *)jarg1;
101034 }
101035
101036 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101037     return (Dali::Toolkit::PageTurnView *)jarg1;
101038 }
101039
101040 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101041     return (Dali::Toolkit::Button *)jarg1;
101042 }
101043
101044 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101045     return (Dali::BaseHandle *)jarg1;
101046 }
101047
101048 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101049     return (Dali::BaseHandle *)jarg1;
101050 }
101051
101052 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101053     return (Dali::BaseHandle *)jarg1;
101054 }
101055
101056
101057 #ifdef __cplusplus
101058 }
101059 #endif
101060