dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.12
   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 static 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 static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 222   { SWIG_CSharpArgumentException, NULL },
 223   { SWIG_CSharpArgumentNullException, NULL },
 224   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 225 };
 226
 227 static 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 static 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 static 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 SWIGINTERN 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 <typeinfo>
 418 #include <stdexcept>
 419
 420
 421 #define SWIGSTDCALL
 422
 423
 424 #include <dali/dali.h>
 425 #include <dali-toolkit/dali-toolkit.h>
 426
 427 #include <dali/devel-api/actors/actor-devel.h>
 428
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/window.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 440 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 441 #include <dali/devel-api/adaptor-framework/window-devel.h>
 442
 443 #include <dali/devel-api/images/nine-patch-image.h>
 444
 445 #include <dali-toolkit/devel-api/builder/builder.h>
 446
 447 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 448 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 449
 450 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 451 #include <dali-toolkit/devel-api/controls/progress-bar/progress-bar.h>
 452 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 456 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 457 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 458
 459 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 460 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 461 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 462
 463 #include <dali-toolkit/devel-api/visuals/text-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469 // add here SWIG version check
 470
 471 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 472 // disable Swig-dependent warnings
 473
 474 // 'identifier1' has C-linkage specified,
 475 // but returns UDT 'identifier2' which is incompatible with C
 476 #pragma warning(disable: 4190)
 477
 478 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 479 #pragma warning(disable: 4800)
 480
 481 // debug info too long etc etc
 482 #pragma warning(disable: 4786)
 483 #endif
 484
 485
 486 #include <typeinfo>
 487 #include <stdexcept>
 488
 489
 490 #include <string>
 491
 492
 493 #include <vector>
 494 #include <algorithm>
 495 #include <stdexcept>
 496
 497
 498 #include <map>
 499 #include <algorithm>
 500 #include <stdexcept>
 501
 502
 503 #include <utility>
 504
 505
 506 typedef float floatp;
 507
 508 SWIGINTERN floatp *new_floatp(){
 509   return new float();
 510 }
 511 SWIGINTERN void delete_floatp(floatp *self){
 512   if (self) delete self;
 513 }
 514 SWIGINTERN void floatp_assign(floatp *self,float value){
 515   *self = value;
 516 }
 517 SWIGINTERN float floatp_value(floatp *self){
 518   return *self;
 519 }
 520 SWIGINTERN float *floatp_cast(floatp *self){
 521   return self;
 522 }
 523 SWIGINTERN floatp *floatp_frompointer(float *t){
 524   return (floatp *) t;
 525 }
 526
 527 typedef int intp;
 528
 529 SWIGINTERN intp *new_intp(){
 530   return new int();
 531 }
 532 SWIGINTERN void delete_intp(intp *self){
 533   if (self) delete self;
 534 }
 535 SWIGINTERN void intp_assign(intp *self,int value){
 536   *self = value;
 537 }
 538 SWIGINTERN int intp_value(intp *self){
 539   return *self;
 540 }
 541 SWIGINTERN int *intp_cast(intp *self){
 542   return self;
 543 }
 544 SWIGINTERN intp *intp_frompointer(int *t){
 545   return (intp *) t;
 546 }
 547
 548 typedef double doublep;
 549
 550 SWIGINTERN doublep *new_doublep(){
 551   return new double();
 552 }
 553 SWIGINTERN void delete_doublep(doublep *self){
 554   if (self) delete self;
 555 }
 556 SWIGINTERN void doublep_assign(doublep *self,double value){
 557   *self = value;
 558 }
 559 SWIGINTERN double doublep_value(doublep *self){
 560   return *self;
 561 }
 562 SWIGINTERN double *doublep_cast(doublep *self){
 563   return self;
 564 }
 565 SWIGINTERN doublep *doublep_frompointer(double *t){
 566   return (doublep *) t;
 567 }
 568
 569 typedef unsigned int uintp;
 570
 571 SWIGINTERN uintp *new_uintp(){
 572   return new unsigned int();
 573 }
 574 SWIGINTERN void delete_uintp(uintp *self){
 575   if (self) delete self;
 576 }
 577 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 578   *self = value;
 579 }
 580 SWIGINTERN unsigned int uintp_value(uintp *self){
 581   return *self;
 582 }
 583 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 584   return self;
 585 }
 586 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 587   return (uintp *) t;
 588 }
 589
 590 typedef unsigned short ushortp;
 591
 592 SWIGINTERN ushortp *new_ushortp(){
 593   return new unsigned short();
 594 }
 595 SWIGINTERN void delete_ushortp(ushortp *self){
 596   if (self) delete self;
 597 }
 598 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 599   *self = value;
 600 }
 601 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 602   return *self;
 603 }
 604 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 605   return self;
 606 }
 607 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 608   return (ushortp *) t;
 609 }
 610
 611 unsigned int int_to_uint(int x) {
 612    return (unsigned int) x;
 613 }
 614
 615
 616 using namespace Dali;
 617 using namespace Dali::Toolkit;
 618
 619 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 620
 621      // C++ code. DALi uses Handle <-> Body design pattern.
 622      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 623      // Handles in DALi can be converted into a boolean type
 624      // to check if the handle has a valid body attached to it.
 625      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 626      if( *self )
 627      {
 628        return true;
 629      }
 630      else
 631      {
 632        return false;
 633      }
 634     }
 635 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 636
 637      // C++ code. Check if two handles reference the same implemtion
 638      if( *self == rhs)
 639      {
 640        return true;
 641      }
 642      else
 643      {
 644        return false;
 645      }
 646     }
 647 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 648      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 649    }
 650 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){
 651      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 652    }
 653 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 654         std::vector< Dali::TouchPoint >* pv = 0;
 655         if (capacity >= 0) {
 656           pv = new std::vector< Dali::TouchPoint >();
 657           pv->reserve(capacity);
 658        } else {
 659           throw std::out_of_range("capacity");
 660        }
 661        return pv;
 662       }
 663 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 664         if (index>=0 && index<(int)self->size())
 665           return (*self)[index];
 666         else
 667           throw std::out_of_range("index");
 668       }
 669 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 670         if (index>=0 && index<(int)self->size())
 671           return (*self)[index];
 672         else
 673           throw std::out_of_range("index");
 674       }
 675 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 676         if (index>=0 && index<(int)self->size())
 677           (*self)[index] = val;
 678         else
 679           throw std::out_of_range("index");
 680       }
 681 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 682         self->insert(self->end(), values.begin(), values.end());
 683       }
 684 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 685         if (index < 0)
 686           throw std::out_of_range("index");
 687         if (count < 0)
 688           throw std::out_of_range("count");
 689         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 690           throw std::invalid_argument("invalid range");
 691         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 692       }
 693 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 694         if (index>=0 && index<(int)self->size()+1)
 695           self->insert(self->begin()+index, x);
 696         else
 697           throw std::out_of_range("index");
 698       }
 699 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 700         if (index>=0 && index<(int)self->size()+1)
 701           self->insert(self->begin()+index, values.begin(), values.end());
 702         else
 703           throw std::out_of_range("index");
 704       }
 705 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 706         if (index>=0 && index<(int)self->size())
 707           self->erase(self->begin() + index);
 708         else
 709           throw std::out_of_range("index");
 710       }
 711 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 712         if (index < 0)
 713           throw std::out_of_range("index");
 714         if (count < 0)
 715           throw std::out_of_range("count");
 716         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 717           throw std::invalid_argument("invalid range");
 718         self->erase(self->begin()+index, self->begin()+index+count);
 719       }
 720 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 721         if (count < 0)
 722           throw std::out_of_range("count");
 723         return new std::vector< Dali::TouchPoint >(count, value);
 724       }
 725 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 726         std::reverse(self->begin(), self->end());
 727       }
 728 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 729         if (index < 0)
 730           throw std::out_of_range("index");
 731         if (count < 0)
 732           throw std::out_of_range("count");
 733         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 734           throw std::invalid_argument("invalid range");
 735         std::reverse(self->begin()+index, self->begin()+index+count);
 736       }
 737 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 738         if (index < 0)
 739           throw std::out_of_range("index");
 740         if (index+values.size() > self->size())
 741           throw std::out_of_range("index");
 742         std::copy(values.begin(), values.end(), self->begin()+index);
 743       }
 744 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 745          return self->Empty();
 746       }
 747 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 748         return self->GetConnectionCount();
 749       }
 750 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 751           self->Connect( func );
 752       }
 753 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 754           self->Disconnect( func );
 755       }
 756 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 757           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 758 /*@SWIG@*/ self->Emit( arg );
 759       }
 760 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 761          return self->Empty();
 762       }
 763 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 764         return self->GetConnectionCount();
 765       }
 766 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 767           self->Connect( func );
 768       }
 769 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 770           self->Disconnect( func );
 771       }
 772 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 773           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 774 /*@SWIG@*/ self->Emit( arg );
 775       }
 776 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 777          return self->Empty();
 778       }
 779 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){
 780         return self->GetConnectionCount();
 781       }
 782 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 *)){
 783           self->Connect( func );
 784       }
 785 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 *)){
 786           self->Disconnect( func );
 787       }
 788 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){
 789           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 790 /*@SWIG@*/ self->Emit( arg );
 791       }
 792 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 793          return self->Empty();
 794       }
 795 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 796         return self->GetConnectionCount();
 797       }
 798 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 799           self->Connect( func );
 800       }
 801 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 802           self->Disconnect( func );
 803       }
 804 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 805           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 806 /*@SWIG@*/ self->Emit( arg );
 807       }
 808 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 809          return self->Empty();
 810       }
 811 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 812         return self->GetConnectionCount();
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 815           self->Connect( func );
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 818           self->Disconnect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 821           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 822 /*@SWIG@*/ self->Emit( arg );
 823       }
 824 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){
 825          return self->Empty();
 826       }
 827 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){
 828         return self->GetConnectionCount();
 829       }
 830 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 &)){
 831         self->Connect( func );
 832       }
 833 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 &)){
 834         self->Disconnect( func );
 835       }
 836 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){
 837         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 838 /*@SWIG@*/ self->Emit( arg1, arg2 );
 839       }
 840 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){
 841          return self->Empty();
 842       }
 843 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){
 844         return self->GetConnectionCount();
 845       }
 846 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 &)){
 847         self->Connect( func );
 848       }
 849 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 &)){
 850         self->Disconnect( func );
 851       }
 852 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){
 853         return self->Emit( arg1, arg2 );
 854       }
 855 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){
 856          return self->Empty();
 857       }
 858 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){
 859         return self->GetConnectionCount();
 860       }
 861 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 &)){
 862         self->Connect( func );
 863       }
 864 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 &)){
 865         self->Disconnect( func );
 866       }
 867 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){
 868         return self->Emit( arg1, arg2 );
 869       }
 870 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){
 871          return self->Empty();
 872       }
 873 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){
 874         return self->GetConnectionCount();
 875       }
 876 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 &)){
 877         self->Connect( func );
 878       }
 879 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 &)){
 880         self->Disconnect( func );
 881       }
 882 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){
 883         return self->Emit( arg1, arg2 );
 884       }
 885 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 886          return self->Empty();
 887       }
 888 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 889         return self->GetConnectionCount();
 890       }
 891 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 892           self->Connect( func );
 893       }
 894 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 895           self->Disconnect( func );
 896       }
 897 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 898           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 899 /*@SWIG@*/ self->Emit( arg );
 900       }
 901 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 902          return self->Empty();
 903       }
 904 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){
 905         return self->GetConnectionCount();
 906       }
 907 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 &)){
 908           self->Connect( func );
 909       }
 910 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 &)){
 911           self->Disconnect( func );
 912       }
 913 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){
 914           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 915 /*@SWIG@*/ self->Emit( arg );
 916       }
 917 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 918          return self->Empty();
 919       }
 920 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){
 921         return self->GetConnectionCount();
 922       }
 923 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 &)){
 924           self->Connect( func );
 925       }
 926 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 &)){
 927           self->Disconnect( func );
 928       }
 929 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){
 930           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 931 /*@SWIG@*/ self->Emit( arg );
 932       }
 933 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 934          return self->Empty();
 935       }
 936 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){
 937         return self->GetConnectionCount();
 938       }
 939 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 &)){
 940           self->Connect( func );
 941       }
 942 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 &)){
 943           self->Disconnect( func );
 944       }
 945 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){
 946           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 947 /*@SWIG@*/ self->Emit( arg );
 948       }
 949 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){
 950          return self->Empty();
 951       }
 952 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){
 953         return self->GetConnectionCount();
 954       }
 955 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 &)){
 956         self->Connect( func );
 957       }
 958 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 &)){
 959         self->Disconnect( func );
 960       }
 961 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){
 962         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 963 /*@SWIG@*/ self->Emit( arg1, arg2 );
 964       }
 965 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){
 966          return self->Empty();
 967       }
 968 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){
 969         return self->GetConnectionCount();
 970       }
 971 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 &)){
 972         self->Connect( func );
 973       }
 974 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 &)){
 975         self->Disconnect( func );
 976       }
 977 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){
 978         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 979 /*@SWIG@*/ self->Emit( arg1, arg2 );
 980       }
 981 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){
 982          return self->Empty();
 983       }
 984 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){
 985         return self->GetConnectionCount();
 986       }
 987 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 &)){
 988         self->Connect( func );
 989       }
 990 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 &)){
 991         self->Disconnect( func );
 992       }
 993 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){
 994         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 995 /*@SWIG@*/ self->Emit( arg1, arg2 );
 996       }
 997 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
 998          return self->Empty();
 999       }
1000 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1001         return self->GetConnectionCount();
1002       }
1003 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1004           self->Connect( func );
1005       }
1006 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1007           self->Disconnect( func );
1008       }
1009 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1010           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1011 /*@SWIG@*/ self->Emit( arg );
1012       }
1013 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1014          return self->Empty();
1015       }
1016 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1017         return self->GetConnectionCount();
1018       }
1019 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1020           self->Connect( func );
1021       }
1022 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1023           self->Disconnect( func );
1024       }
1025 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1026           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1027 /*@SWIG@*/ self->Emit( arg );
1028       }
1029
1030   // keep argcs and argv so they're always available to DALi
1031   int argC = 1;
1032   char **argV = NULL;
1033
1034 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1035          return self->Empty();
1036       }
1037 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1038         return self->GetConnectionCount();
1039       }
1040 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1041           self->Connect( func );
1042       }
1043 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1044           self->Disconnect( func );
1045       }
1046 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1047           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1048 /*@SWIG@*/ self->Emit( arg );
1049       }
1050 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1051          return self->Empty();
1052       }
1053 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &,void *) > const *self){
1054         return self->GetConnectionCount();
1055       }
1056 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1057         self->Connect( func );
1058       }
1059 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &,void *) > *self,void (*func)(Dali::Application &,void *)){
1060         self->Disconnect( func );
1061       }
1062 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::Application &,void *) > *self,Dali::Application &arg1,void *arg2){
1063         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1064 /*@SWIG@*/ self->Emit( arg1, arg2 );
1065       }
1066 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1067          return self->Empty();
1068       }
1069 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1070         return self->GetConnectionCount();
1071       }
1072 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1073           self->Connect( func );
1074       }
1075 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1076           self->Disconnect( func );
1077       }
1078 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1079           return self->Emit();
1080       }
1081 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1082         std::vector< unsigned int >* pv = 0;
1083         if (capacity >= 0) {
1084           pv = new std::vector< unsigned int >();
1085           pv->reserve(capacity);
1086        } else {
1087           throw std::out_of_range("capacity");
1088        }
1089        return pv;
1090       }
1091 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1092         if (index>=0 && index<(int)self->size())
1093           return (*self)[index];
1094         else
1095           throw std::out_of_range("index");
1096       }
1097 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1098         if (index>=0 && index<(int)self->size())
1099           return (*self)[index];
1100         else
1101           throw std::out_of_range("index");
1102       }
1103 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1104         if (index>=0 && index<(int)self->size())
1105           (*self)[index] = val;
1106         else
1107           throw std::out_of_range("index");
1108       }
1109 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1110         self->insert(self->end(), values.begin(), values.end());
1111       }
1112 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1113         if (index < 0)
1114           throw std::out_of_range("index");
1115         if (count < 0)
1116           throw std::out_of_range("count");
1117         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1118           throw std::invalid_argument("invalid range");
1119         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1120       }
1121 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1122         if (index>=0 && index<(int)self->size()+1)
1123           self->insert(self->begin()+index, x);
1124         else
1125           throw std::out_of_range("index");
1126       }
1127 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1128         if (index>=0 && index<(int)self->size()+1)
1129           self->insert(self->begin()+index, values.begin(), values.end());
1130         else
1131           throw std::out_of_range("index");
1132       }
1133 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1134         if (index>=0 && index<(int)self->size())
1135           self->erase(self->begin() + index);
1136         else
1137           throw std::out_of_range("index");
1138       }
1139 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1140         if (index < 0)
1141           throw std::out_of_range("index");
1142         if (count < 0)
1143           throw std::out_of_range("count");
1144         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1145           throw std::invalid_argument("invalid range");
1146         self->erase(self->begin()+index, self->begin()+index+count);
1147       }
1148 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1149         if (count < 0)
1150           throw std::out_of_range("count");
1151         return new std::vector< unsigned int >(count, value);
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1154         std::reverse(self->begin(), self->end());
1155       }
1156 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1157         if (index < 0)
1158           throw std::out_of_range("index");
1159         if (count < 0)
1160           throw std::out_of_range("count");
1161         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1162           throw std::invalid_argument("invalid range");
1163         std::reverse(self->begin()+index, self->begin()+index+count);
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1166         if (index < 0)
1167           throw std::out_of_range("index");
1168         if (index+values.size() > self->size())
1169           throw std::out_of_range("index");
1170         std::copy(values.begin(), values.end(), self->begin()+index);
1171       }
1172 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1173         return std::find(self->begin(), self->end(), value) != self->end();
1174       }
1175 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1176         int index = -1;
1177         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1178         if (it != self->end())
1179           index = (int)(it - self->begin());
1180         return index;
1181       }
1182 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1183         int index = -1;
1184         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1185         if (rit != self->rend())
1186           index = (int)(self->rend() - 1 - rit);
1187         return index;
1188       }
1189 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1190         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1191         if (it != self->end()) {
1192           self->erase(it);
1193           return true;
1194         }
1195         return false;
1196       }
1197 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){
1198         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1199         if (capacity >= 0) {
1200           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1201           pv->reserve(capacity);
1202        } else {
1203           throw std::out_of_range("capacity");
1204        }
1205        return pv;
1206       }
1207 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){
1208         if (index>=0 && index<(int)self->size())
1209           return (*self)[index];
1210         else
1211           throw std::out_of_range("index");
1212       }
1213 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){
1214         if (index>=0 && index<(int)self->size())
1215           return (*self)[index];
1216         else
1217           throw std::out_of_range("index");
1218       }
1219 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){
1220         if (index>=0 && index<(int)self->size())
1221           (*self)[index] = val;
1222         else
1223           throw std::out_of_range("index");
1224       }
1225 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){
1226         self->insert(self->end(), values.begin(), values.end());
1227       }
1228 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){
1229         if (index < 0)
1230           throw std::out_of_range("index");
1231         if (count < 0)
1232           throw std::out_of_range("count");
1233         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1234           throw std::invalid_argument("invalid range");
1235         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1236       }
1237 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){
1238         if (index>=0 && index<(int)self->size()+1)
1239           self->insert(self->begin()+index, x);
1240         else
1241           throw std::out_of_range("index");
1242       }
1243 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){
1244         if (index>=0 && index<(int)self->size()+1)
1245           self->insert(self->begin()+index, values.begin(), values.end());
1246         else
1247           throw std::out_of_range("index");
1248       }
1249 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){
1250         if (index>=0 && index<(int)self->size())
1251           self->erase(self->begin() + index);
1252         else
1253           throw std::out_of_range("index");
1254       }
1255 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){
1256         if (index < 0)
1257           throw std::out_of_range("index");
1258         if (count < 0)
1259           throw std::out_of_range("count");
1260         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1261           throw std::invalid_argument("invalid range");
1262         self->erase(self->begin()+index, self->begin()+index+count);
1263       }
1264 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){
1265         if (count < 0)
1266           throw std::out_of_range("count");
1267         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1268       }
1269 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){
1270         std::reverse(self->begin(), self->end());
1271       }
1272 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){
1273         if (index < 0)
1274           throw std::out_of_range("index");
1275         if (count < 0)
1276           throw std::out_of_range("count");
1277         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1278           throw std::invalid_argument("invalid range");
1279         std::reverse(self->begin()+index, self->begin()+index+count);
1280       }
1281 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){
1282         if (index < 0)
1283           throw std::out_of_range("index");
1284         if (index+values.size() > self->size())
1285           throw std::out_of_range("index");
1286         std::copy(values.begin(), values.end(), self->begin()+index);
1287       }
1288 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1289         std::vector< Dali::Actor >* pv = 0;
1290         if (capacity >= 0) {
1291           pv = new std::vector< Dali::Actor >();
1292           pv->reserve(capacity);
1293        } else {
1294           throw std::out_of_range("capacity");
1295        }
1296        return pv;
1297       }
1298 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1299         if (index>=0 && index<(int)self->size())
1300           return (*self)[index];
1301         else
1302           throw std::out_of_range("index");
1303       }
1304 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1305         if (index>=0 && index<(int)self->size())
1306           return (*self)[index];
1307         else
1308           throw std::out_of_range("index");
1309       }
1310 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1311         if (index>=0 && index<(int)self->size())
1312           (*self)[index] = val;
1313         else
1314           throw std::out_of_range("index");
1315       }
1316 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1317         self->insert(self->end(), values.begin(), values.end());
1318       }
1319 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1320         if (index < 0)
1321           throw std::out_of_range("index");
1322         if (count < 0)
1323           throw std::out_of_range("count");
1324         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1325           throw std::invalid_argument("invalid range");
1326         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1327       }
1328 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1329         if (index>=0 && index<(int)self->size()+1)
1330           self->insert(self->begin()+index, x);
1331         else
1332           throw std::out_of_range("index");
1333       }
1334 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1335         if (index>=0 && index<(int)self->size()+1)
1336           self->insert(self->begin()+index, values.begin(), values.end());
1337         else
1338           throw std::out_of_range("index");
1339       }
1340 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1341         if (index>=0 && index<(int)self->size())
1342           self->erase(self->begin() + index);
1343         else
1344           throw std::out_of_range("index");
1345       }
1346 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1347         if (index < 0)
1348           throw std::out_of_range("index");
1349         if (count < 0)
1350           throw std::out_of_range("count");
1351         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1352           throw std::invalid_argument("invalid range");
1353         self->erase(self->begin()+index, self->begin()+index+count);
1354       }
1355 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1356         if (count < 0)
1357           throw std::out_of_range("count");
1358         return new std::vector< Dali::Actor >(count, value);
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1361         std::reverse(self->begin(), self->end());
1362       }
1363 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1364         if (index < 0)
1365           throw std::out_of_range("index");
1366         if (count < 0)
1367           throw std::out_of_range("count");
1368         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1369           throw std::invalid_argument("invalid range");
1370         std::reverse(self->begin()+index, self->begin()+index+count);
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1373         if (index < 0)
1374           throw std::out_of_range("index");
1375         if (index+values.size() > self->size())
1376           throw std::out_of_range("index");
1377         std::copy(values.begin(), values.end(), self->begin()+index);
1378       }
1379 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1380          return self->Empty();
1381       }
1382 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1383         return self->GetConnectionCount();
1384       }
1385 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 &)){
1386           self->Connect( func );
1387       }
1388 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 &)){
1389           self->Disconnect( func );
1390       }
1391 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){
1392           return self->Emit( arg );
1393       }
1394 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){
1395          return self->Empty();
1396       }
1397 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){
1398         return self->GetConnectionCount();
1399       }
1400 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)){
1401         self->Connect( func );
1402       }
1403 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)){
1404         self->Disconnect( func );
1405       }
1406 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){
1407         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1408 /*@SWIG@*/ self->Emit( arg1, arg2 );
1409       }
1410 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1411          return self->Empty();
1412       }
1413 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){
1414         return self->GetConnectionCount();
1415       }
1416 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)){
1417         self->Connect( func );
1418       }
1419 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)){
1420         self->Disconnect( func );
1421       }
1422 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){
1423         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1424 /*@SWIG@*/ self->Emit( arg1, arg2 );
1425       }
1426 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1427          return self->Empty();
1428       }
1429 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1430         return self->GetConnectionCount();
1431       }
1432 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)){
1433         self->Connect( func );
1434       }
1435 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)){
1436         self->Disconnect( func );
1437       }
1438 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){
1439         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1440 /*@SWIG@*/ self->Emit( arg1, arg2 );
1441       }
1442 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){
1443          return self->Empty();
1444       }
1445 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){
1446         return self->GetConnectionCount();
1447       }
1448 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)){
1449         self->Connect( func );
1450       }
1451 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)){
1452         self->Disconnect( func );
1453       }
1454 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){
1455         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1456 /*@SWIG@*/ self->Emit( arg1, arg2 );
1457       }
1458 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1459          return self->Empty();
1460       }
1461 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1462         return self->GetConnectionCount();
1463       }
1464 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)){
1465           self->Connect( func );
1466       }
1467 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)){
1468           self->Disconnect( func );
1469       }
1470 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1471           return self->Emit( arg );
1472       }
1473 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1474          return self->Empty();
1475       }
1476 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1477         return self->GetConnectionCount();
1478       }
1479 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)){
1480           self->Connect( func );
1481       }
1482 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)){
1483           self->Disconnect( func );
1484       }
1485 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1486           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1487 /*@SWIG@*/ self->Emit( arg );
1488       }
1489 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){
1490          return self->Empty();
1491       }
1492 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){
1493         return self->GetConnectionCount();
1494       }
1495 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)){
1496           return self->Connect( func );
1497       }
1498 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)){
1499           self->Disconnect( func );
1500       }
1501 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){
1502           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1503 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1504       }
1505 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1506          return self->Empty();
1507       }
1508 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1509         return self->GetConnectionCount();
1510       }
1511 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)){
1512           self->Connect( func );
1513       }
1514 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)){
1515           self->Disconnect( func );
1516       }
1517 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1518           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1519 /*@SWIG@*/ self->Emit( arg );
1520       }
1521 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){
1522          return self->Empty();
1523       }
1524 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){
1525         return self->GetConnectionCount();
1526       }
1527 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)){
1528           return self->Connect( func );
1529       }
1530 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)){
1531           self->Disconnect( func );
1532       }
1533 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){
1534           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1535 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1536       }
1537 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){
1538          return self->Empty();
1539       }
1540 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){
1541         return self->GetConnectionCount();
1542       }
1543 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 &)){
1544           self->Connect( func );
1545       }
1546 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 &)){
1547           self->Disconnect( func );
1548       }
1549 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){
1550           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1551 /*@SWIG@*/ self->Emit( arg );
1552       }
1553 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1554          return self->Empty();
1555       }
1556 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){
1557         return self->GetConnectionCount();
1558       }
1559 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 &)){
1560           self->Connect( func );
1561       }
1562 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 &)){
1563           self->Disconnect( func );
1564       }
1565 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){
1566           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1567 /*@SWIG@*/ self->Emit( arg );
1568       }
1569 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1570          return self->Empty();
1571       }
1572 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1573         return self->GetConnectionCount();
1574       }
1575 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1576           self->Connect( func );
1577       }
1578 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,void (*func)(Dali::Toolkit::TextEditor)){
1579           self->Disconnect( func );
1580       }
1581 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1582           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1583 /*@SWIG@*/ self->Emit( arg );
1584       }
1585 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1586          return self->Empty();
1587       }
1588 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1589         return self->GetConnectionCount();
1590       }
1591 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1592           self->Connect( func );
1593       }
1594 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(Dali::Signal< void (Dali::Toolkit::TextField) > *self,void (*func)(Dali::Toolkit::TextField)){
1595           self->Disconnect( func );
1596       }
1597 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1598           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1599 /*@SWIG@*/ self->Emit( arg );
1600       }
1601 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){
1602          return self->Empty();
1603       }
1604 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){
1605         return self->GetConnectionCount();
1606       }
1607 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 &)){
1608         self->Connect( func );
1609       }
1610 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 &)){
1611         self->Disconnect( func );
1612       }
1613 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){
1614         return self->Emit( arg1, arg2 );
1615       }
1616 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1617          return self->Empty();
1618       }
1619 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1620         return self->GetConnectionCount();
1621       }
1622 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)){
1623           self->Connect( func );
1624       }
1625 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)){
1626           self->Disconnect( func );
1627       }
1628 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1629           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1630 /*@SWIG@*/ self->Emit( arg );
1631       }
1632 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1633          return self->Empty();
1634       }
1635 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1636         return self->GetConnectionCount();
1637       }
1638 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 &)){
1639           self->Connect( func );
1640       }
1641 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 &)){
1642           self->Disconnect( func );
1643       }
1644 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){
1645           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1646 /*@SWIG@*/ self->Emit( arg );
1647       }
1648 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1649          return self->Empty();
1650       }
1651 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){
1652         return self->GetConnectionCount();
1653       }
1654 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)){
1655         self->Connect( func );
1656       }
1657 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)){
1658         self->Disconnect( func );
1659       }
1660 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){
1661         return self->Emit( arg1, arg2 );
1662       }
1663 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1664          return self->Empty();
1665       }
1666 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){
1667         return self->GetConnectionCount();
1668       }
1669 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)){
1670         self->Connect( func );
1671       }
1672 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)){
1673         self->Disconnect( func );
1674       }
1675 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){
1676         return self->Emit( arg1, arg2 );
1677       }
1678
1679
1680 /* ---------------------------------------------------
1681  * C++ director class methods
1682  * --------------------------------------------------- */
1683
1684 #include "dali_wrap.h"
1685
1686 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1687   swig_init_callbacks();
1688 }
1689
1690 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1691
1692 }
1693
1694
1695 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1696   int jdepth  ;
1697
1698   if (!swig_callbackOnStageConnection) {
1699     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1700     return;
1701   } else {
1702     jdepth = depth;
1703     swig_callbackOnStageConnection(jdepth);
1704   }
1705 }
1706
1707 void SwigDirector_ViewImpl::OnStageDisconnection() {
1708   if (!swig_callbackOnStageDisconnection) {
1709     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1710     return;
1711   } else {
1712     swig_callbackOnStageDisconnection();
1713   }
1714 }
1715
1716 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1717   void * jchild = 0 ;
1718
1719   if (!swig_callbackOnChildAdd) {
1720     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1721     return;
1722   } else {
1723     jchild = (Dali::Actor *) &child;
1724     swig_callbackOnChildAdd(jchild);
1725   }
1726 }
1727
1728 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1729   void * jchild = 0 ;
1730
1731   if (!swig_callbackOnChildRemove) {
1732     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1733     return;
1734   } else {
1735     jchild = (Dali::Actor *) &child;
1736     swig_callbackOnChildRemove(jchild);
1737   }
1738 }
1739
1740 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1741   int jindex  ;
1742   void * jpropertyValue  ;
1743
1744   if (!swig_callbackOnPropertySet) {
1745     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1746     return;
1747   } else {
1748     jindex = index;
1749     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1750     swig_callbackOnPropertySet(jindex, jpropertyValue);
1751   }
1752 }
1753
1754 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1755   void * jtargetSize = 0 ;
1756
1757   if (!swig_callbackOnSizeSet) {
1758     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1759     return;
1760   } else {
1761     jtargetSize = (Dali::Vector3 *) &targetSize;
1762     swig_callbackOnSizeSet(jtargetSize);
1763   }
1764 }
1765
1766 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1767   void * janimation = 0 ;
1768   void * jtargetSize = 0 ;
1769
1770   if (!swig_callbackOnSizeAnimation) {
1771     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1772     return;
1773   } else {
1774     janimation = (Dali::Animation *) &animation;
1775     jtargetSize = (Dali::Vector3 *) &targetSize;
1776     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1777   }
1778 }
1779
1780 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1781   bool c_result = SwigValueInit< bool >() ;
1782   unsigned int jresult = 0 ;
1783   void * jarg0 = 0 ;
1784
1785   if (!swig_callbackOnTouchEvent) {
1786     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1787   } else {
1788     jarg0 = (Dali::TouchEvent *) &event;
1789     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1790     c_result = jresult ? true : false;
1791   }
1792   return c_result;
1793 }
1794
1795 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1796   bool c_result = SwigValueInit< bool >() ;
1797   unsigned int jresult = 0 ;
1798   void * jarg0 = 0 ;
1799
1800   if (!swig_callbackOnHoverEvent) {
1801     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1802   } else {
1803     jarg0 = (Dali::HoverEvent *) &event;
1804     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1805     c_result = jresult ? true : false;
1806   }
1807   return c_result;
1808 }
1809
1810 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1811   bool c_result = SwigValueInit< bool >() ;
1812   unsigned int jresult = 0 ;
1813   void * jarg0 = 0 ;
1814
1815   if (!swig_callbackOnKeyEvent) {
1816     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1817   } else {
1818     jarg0 = (Dali::KeyEvent *) &event;
1819     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1820     c_result = jresult ? true : false;
1821   }
1822   return c_result;
1823 }
1824
1825 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1826   bool c_result = SwigValueInit< bool >() ;
1827   unsigned int jresult = 0 ;
1828   void * jarg0 = 0 ;
1829
1830   if (!swig_callbackOnWheelEvent) {
1831     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1832   } else {
1833     jarg0 = (Dali::WheelEvent *) &event;
1834     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1835     c_result = jresult ? true : false;
1836   }
1837   return c_result;
1838 }
1839
1840 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1841   void * jsize = 0 ;
1842   void * jcontainer = 0 ;
1843
1844   if (!swig_callbackOnRelayout) {
1845     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1846     return;
1847   } else {
1848     jsize = (Dali::Vector2 *) &size;
1849     jcontainer = (Dali::RelayoutContainer *) &container;
1850     swig_callbackOnRelayout(jsize, jcontainer);
1851   }
1852 }
1853
1854 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1855   int jpolicy  ;
1856   int jdimension  ;
1857
1858   if (!swig_callbackOnSetResizePolicy) {
1859     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1860     return;
1861   } else {
1862     jpolicy = (int)policy;
1863     jdimension = (int)dimension;
1864     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1865   }
1866 }
1867
1868 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1869   Dali::Vector3 c_result ;
1870   void * jresult = 0 ;
1871
1872   if (!swig_callbackGetNaturalSize) {
1873     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1874   } else {
1875     jresult = (void *) swig_callbackGetNaturalSize();
1876     if (!jresult) {
1877       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1878       return c_result;
1879     }
1880     c_result = *(Dali::Vector3 *)jresult;
1881   }
1882   return c_result;
1883 }
1884
1885 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1886   float c_result = SwigValueInit< float >() ;
1887   float jresult = 0 ;
1888   void * jchild = 0 ;
1889   int jdimension  ;
1890
1891   if (!swig_callbackCalculateChildSize) {
1892     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1893   } else {
1894     jchild = (Dali::Actor *) &child;
1895     jdimension = (int)dimension;
1896     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1897     c_result = (float)jresult;
1898   }
1899   return c_result;
1900 }
1901
1902 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1903   float c_result = SwigValueInit< float >() ;
1904   float jresult = 0 ;
1905   float jwidth  ;
1906
1907   if (!swig_callbackGetHeightForWidth) {
1908     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1909   } else {
1910     jwidth = width;
1911     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1912     c_result = (float)jresult;
1913   }
1914   return c_result;
1915 }
1916
1917 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1918   float c_result = SwigValueInit< float >() ;
1919   float jresult = 0 ;
1920   float jheight  ;
1921
1922   if (!swig_callbackGetWidthForHeight) {
1923     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1924   } else {
1925     jheight = height;
1926     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1927     c_result = (float)jresult;
1928   }
1929   return c_result;
1930 }
1931
1932 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1933   bool c_result = SwigValueInit< bool >() ;
1934   unsigned int jresult = 0 ;
1935   int jdimension  ;
1936
1937   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1938     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1939   } else {
1940     jdimension = (int)dimension;
1941     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1942     c_result = jresult ? true : false;
1943   }
1944   return c_result;
1945 }
1946
1947 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1948   int jdimension  ;
1949
1950   if (!swig_callbackOnCalculateRelayoutSize) {
1951     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1952     return;
1953   } else {
1954     jdimension = (int)dimension;
1955     swig_callbackOnCalculateRelayoutSize(jdimension);
1956   }
1957 }
1958
1959 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1960   float jsize  ;
1961   int jdimension  ;
1962
1963   if (!swig_callbackOnLayoutNegotiated) {
1964     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1965     return;
1966   } else {
1967     jsize = size;
1968     jdimension = (int)dimension;
1969     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1970   }
1971 }
1972
1973 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1974   return Dali::CustomActorImpl::GetExtension();
1975 }
1976
1977 void SwigDirector_ViewImpl::OnInitialize() {
1978   if (!swig_callbackOnInitialize) {
1979     Dali::Toolkit::Internal::Control::OnInitialize();
1980     return;
1981   } else {
1982     swig_callbackOnInitialize();
1983   }
1984 }
1985
1986 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
1987   void * jchild = 0 ;
1988
1989   if (!swig_callbackOnControlChildAdd) {
1990     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
1991     return;
1992   } else {
1993     jchild = (Dali::Actor *) &child;
1994     swig_callbackOnControlChildAdd(jchild);
1995   }
1996 }
1997
1998 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
1999   void * jchild = 0 ;
2000
2001   if (!swig_callbackOnControlChildRemove) {
2002     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2003     return;
2004   } else {
2005     jchild = (Dali::Actor *) &child;
2006     swig_callbackOnControlChildRemove(jchild);
2007   }
2008 }
2009
2010 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2011   void * jstyleManager  ;
2012   int jchange  ;
2013
2014   if (!swig_callbackOnStyleChange) {
2015     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2016     return;
2017   } else {
2018     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2019     jchange = (int)change;
2020     swig_callbackOnStyleChange(jstyleManager, jchange);
2021   }
2022 }
2023
2024 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2025   bool c_result = SwigValueInit< bool >() ;
2026   unsigned int jresult = 0 ;
2027
2028   if (!swig_callbackOnAccessibilityActivated) {
2029     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2030   } else {
2031     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2032     c_result = jresult ? true : false;
2033   }
2034   return c_result;
2035 }
2036
2037 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2038   bool c_result = SwigValueInit< bool >() ;
2039   unsigned int jresult = 0 ;
2040   void * jgesture  ;
2041
2042   if (!swig_callbackOnAccessibilityPan) {
2043     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2044   } else {
2045     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2046     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2047     c_result = jresult ? true : false;
2048   }
2049   return c_result;
2050 }
2051
2052 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2053   bool c_result = SwigValueInit< bool >() ;
2054   unsigned int jresult = 0 ;
2055   void * jtouchEvent = 0 ;
2056
2057   if (!swig_callbackOnAccessibilityTouch) {
2058     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2059   } else {
2060     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2061     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2062     c_result = jresult ? true : false;
2063   }
2064   return c_result;
2065 }
2066
2067 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2068   bool c_result = SwigValueInit< bool >() ;
2069   unsigned int jresult = 0 ;
2070   unsigned int jisIncrease  ;
2071
2072   if (!swig_callbackOnAccessibilityValueChange) {
2073     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2074   } else {
2075     jisIncrease = isIncrease;
2076     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2077     c_result = jresult ? true : false;
2078   }
2079   return c_result;
2080 }
2081
2082 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2083   bool c_result = SwigValueInit< bool >() ;
2084   unsigned int jresult = 0 ;
2085
2086   if (!swig_callbackOnAccessibilityZoom) {
2087     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2088   } else {
2089     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2090     c_result = jresult ? true : false;
2091   }
2092   return c_result;
2093 }
2094
2095 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2096   if (!swig_callbackOnKeyInputFocusGained) {
2097     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2098     return;
2099   } else {
2100     swig_callbackOnKeyInputFocusGained();
2101   }
2102 }
2103
2104 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2105   if (!swig_callbackOnKeyInputFocusLost) {
2106     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2107     return;
2108   } else {
2109     swig_callbackOnKeyInputFocusLost();
2110   }
2111 }
2112
2113 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2114   Dali::Actor c_result ;
2115   void * jresult = 0 ;
2116   void * jcurrentFocusedActor  ;
2117   int jdirection  ;
2118   unsigned int jloopEnabled  ;
2119
2120   if (!swig_callbackGetNextKeyboardFocusableActor) {
2121     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2122   } else {
2123     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2124     jdirection = (int)direction;
2125     jloopEnabled = loopEnabled;
2126     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2127     if (!jresult) {
2128       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2129       return c_result;
2130     }
2131     c_result = *(Dali::Actor *)jresult;
2132   }
2133   return c_result;
2134 }
2135
2136 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2137   void * jcommitedFocusableActor  ;
2138
2139   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2140     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2141     return;
2142   } else {
2143     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2144     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2145   }
2146 }
2147
2148 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2149   bool c_result = SwigValueInit< bool >() ;
2150   unsigned int jresult = 0 ;
2151
2152   if (!swig_callbackOnKeyboardEnter) {
2153     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2154   } else {
2155     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2156     c_result = jresult ? true : false;
2157   }
2158   return c_result;
2159 }
2160
2161 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2162   void * jpinch = 0 ;
2163
2164   if (!swig_callbackOnPinch) {
2165     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2166     return;
2167   } else {
2168     jpinch = (Dali::PinchGesture *) &pinch;
2169     swig_callbackOnPinch(jpinch);
2170   }
2171 }
2172
2173 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2174   void * jpan = 0 ;
2175
2176   if (!swig_callbackOnPan) {
2177     Dali::Toolkit::Internal::Control::OnPan(pan);
2178     return;
2179   } else {
2180     jpan = (Dali::PanGesture *) &pan;
2181     swig_callbackOnPan(jpan);
2182   }
2183 }
2184
2185 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2186   void * jtap = 0 ;
2187
2188   if (!swig_callbackOnTap) {
2189     Dali::Toolkit::Internal::Control::OnTap(tap);
2190     return;
2191   } else {
2192     jtap = (Dali::TapGesture *) &tap;
2193     swig_callbackOnTap(jtap);
2194   }
2195 }
2196
2197 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2198   void * jlongPress = 0 ;
2199
2200   if (!swig_callbackOnLongPress) {
2201     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2202     return;
2203   } else {
2204     jlongPress = (Dali::LongPressGesture *) &longPress;
2205     swig_callbackOnLongPress(jlongPress);
2206   }
2207 }
2208
2209 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2210   void * jslotObserver = 0 ;
2211   void * jcallback = 0 ;
2212
2213   if (!swig_callbackSignalConnected) {
2214     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2215     return;
2216   } else {
2217     jslotObserver = (void *) slotObserver;
2218     jcallback = (void *) callback;
2219     swig_callbackSignalConnected(jslotObserver, jcallback);
2220   }
2221 }
2222
2223 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2224   void * jslotObserver = 0 ;
2225   void * jcallback = 0 ;
2226
2227   if (!swig_callbackSignalDisconnected) {
2228     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2229     return;
2230   } else {
2231     jslotObserver = (void *) slotObserver;
2232     jcallback = (void *) callback;
2233     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2234   }
2235 }
2236
2237 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2238   return Dali::Toolkit::Internal::Control::GetControlExtension();
2239 }
2240
2241 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) {
2242   swig_callbackOnStageConnection = callbackOnStageConnection;
2243   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2244   swig_callbackOnChildAdd = callbackOnChildAdd;
2245   swig_callbackOnChildRemove = callbackOnChildRemove;
2246   swig_callbackOnPropertySet = callbackOnPropertySet;
2247   swig_callbackOnSizeSet = callbackOnSizeSet;
2248   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2249   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2250   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2251   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2252   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2253   swig_callbackOnRelayout = callbackOnRelayout;
2254   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2255   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2256   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2257   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2258   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2259   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2260   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2261   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2262   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2263   swig_callbackOnInitialize = callbackOnInitialize;
2264   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2265   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2266   swig_callbackOnStyleChange = callbackOnStyleChange;
2267   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2268   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2269   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2270   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2271   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2272   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2273   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2274   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2275   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2276   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2277   swig_callbackOnPinch = callbackOnPinch;
2278   swig_callbackOnPan = callbackOnPan;
2279   swig_callbackOnTap = callbackOnTap;
2280   swig_callbackOnLongPress = callbackOnLongPress;
2281   swig_callbackSignalConnected = callbackSignalConnected;
2282   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2283 }
2284
2285 void SwigDirector_ViewImpl::swig_init_callbacks() {
2286   swig_callbackOnStageConnection = 0;
2287   swig_callbackOnStageDisconnection = 0;
2288   swig_callbackOnChildAdd = 0;
2289   swig_callbackOnChildRemove = 0;
2290   swig_callbackOnPropertySet = 0;
2291   swig_callbackOnSizeSet = 0;
2292   swig_callbackOnSizeAnimation = 0;
2293   swig_callbackOnTouchEvent = 0;
2294   swig_callbackOnHoverEvent = 0;
2295   swig_callbackOnKeyEvent = 0;
2296   swig_callbackOnWheelEvent = 0;
2297   swig_callbackOnRelayout = 0;
2298   swig_callbackOnSetResizePolicy = 0;
2299   swig_callbackGetNaturalSize = 0;
2300   swig_callbackCalculateChildSize = 0;
2301   swig_callbackGetHeightForWidth = 0;
2302   swig_callbackGetWidthForHeight = 0;
2303   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2304   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2305   swig_callbackOnCalculateRelayoutSize = 0;
2306   swig_callbackOnLayoutNegotiated = 0;
2307   swig_callbackOnInitialize = 0;
2308   swig_callbackOnControlChildAdd = 0;
2309   swig_callbackOnControlChildRemove = 0;
2310   swig_callbackOnStyleChange = 0;
2311   swig_callbackOnAccessibilityActivated = 0;
2312   swig_callbackOnAccessibilityPan = 0;
2313   swig_callbackOnAccessibilityTouch = 0;
2314   swig_callbackOnAccessibilityValueChange = 0;
2315   swig_callbackOnAccessibilityZoom = 0;
2316   swig_callbackOnKeyInputFocusGained = 0;
2317   swig_callbackOnKeyInputFocusLost = 0;
2318   swig_callbackGetNextKeyboardFocusableActor = 0;
2319   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2320   swig_callbackOnKeyboardEnter = 0;
2321   swig_callbackOnPinch = 0;
2322   swig_callbackOnPan = 0;
2323   swig_callbackOnTap = 0;
2324   swig_callbackOnLongPress = 0;
2325   swig_callbackSignalConnected = 0;
2326   swig_callbackSignalDisconnected = 0;
2327 }
2328
2329 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2330   swig_init_callbacks();
2331 }
2332
2333 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2334
2335 }
2336
2337
2338 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2339   unsigned int c_result = SwigValueInit< unsigned int >() ;
2340   unsigned int jresult = 0 ;
2341
2342   if (!swig_callbackGetNumberOfItems) {
2343     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2344   } else {
2345     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2346     c_result = (unsigned int)jresult;
2347   }
2348   return c_result;
2349 }
2350
2351 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2352   Dali::Actor c_result ;
2353   void * jresult = 0 ;
2354   unsigned int jitemId  ;
2355
2356   if (!swig_callbackNewItem) {
2357     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2358   } else {
2359     jitemId = itemId;
2360     jresult = (void *) swig_callbackNewItem(jitemId);
2361     if (!jresult) {
2362       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2363       return c_result;
2364     }
2365     c_result = *(Dali::Actor *)jresult;
2366   }
2367   return c_result;
2368 }
2369
2370 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2371   unsigned int jitemId  ;
2372   void * jactor  ;
2373
2374   if (!swig_callbackItemReleased) {
2375     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2376     return;
2377   } else {
2378     jitemId = itemId;
2379     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2380     swig_callbackItemReleased(jitemId, jactor);
2381   }
2382 }
2383
2384 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2385   return Dali::Toolkit::ItemFactory::GetExtension();
2386 }
2387
2388 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2389   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2390   swig_callbackNewItem = callbackNewItem;
2391   swig_callbackItemReleased = callbackItemReleased;
2392 }
2393
2394 void SwigDirector_ItemFactory::swig_init_callbacks() {
2395   swig_callbackGetNumberOfItems = 0;
2396   swig_callbackNewItem = 0;
2397   swig_callbackItemReleased = 0;
2398 }
2399
2400 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2401   swig_init_callbacks();
2402 }
2403
2404 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2405
2406 }
2407
2408
2409 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2410   Dali::Actor c_result ;
2411   void * jresult = 0 ;
2412   void * jcurrent  ;
2413   void * jproposed  ;
2414   int jdirection  ;
2415
2416   if (!swig_callbackGetNextFocusableActor) {
2417     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2418   } else {
2419     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2420     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2421     jdirection = (int)direction;
2422     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2423     if (!jresult) {
2424       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2425       return c_result;
2426     }
2427     c_result = *(Dali::Actor *)jresult;
2428   }
2429   return c_result;
2430 }
2431
2432 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2433   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2434 }
2435
2436 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2437   swig_callbackGetNextFocusableActor = 0;
2438 }
2439
2440
2441 #ifdef __cplusplus
2442 extern "C" {
2443 #endif
2444
2445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2446   void * jresult ;
2447   floatp *result = 0 ;
2448
2449   {
2450     try {
2451       result = (floatp *)new_floatp();
2452     } catch (std::out_of_range& e) {
2453       {
2454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2455       };
2456     } catch (std::exception& e) {
2457       {
2458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2459       };
2460     } catch (...) {
2461       {
2462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2463       };
2464     }
2465   }
2466   jresult = (void *)result;
2467   return jresult;
2468 }
2469
2470
2471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2472   floatp *arg1 = (floatp *) 0 ;
2473
2474   arg1 = (floatp *)jarg1;
2475   {
2476     try {
2477       delete_floatp(arg1);
2478     } catch (std::out_of_range& e) {
2479       {
2480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2481       };
2482     } catch (std::exception& e) {
2483       {
2484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2485       };
2486     } catch (...) {
2487       {
2488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2489       };
2490     }
2491   }
2492 }
2493
2494
2495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2496   floatp *arg1 = (floatp *) 0 ;
2497   float arg2 ;
2498
2499   arg1 = (floatp *)jarg1;
2500   arg2 = (float)jarg2;
2501   {
2502     try {
2503       floatp_assign(arg1,arg2);
2504     } catch (std::out_of_range& e) {
2505       {
2506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2507       };
2508     } catch (std::exception& e) {
2509       {
2510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2511       };
2512     } catch (...) {
2513       {
2514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2515       };
2516     }
2517   }
2518 }
2519
2520
2521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2522   float jresult ;
2523   floatp *arg1 = (floatp *) 0 ;
2524   float result;
2525
2526   arg1 = (floatp *)jarg1;
2527   {
2528     try {
2529       result = (float)floatp_value(arg1);
2530     } catch (std::out_of_range& e) {
2531       {
2532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2533       };
2534     } catch (std::exception& e) {
2535       {
2536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2537       };
2538     } catch (...) {
2539       {
2540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2541       };
2542     }
2543   }
2544   jresult = result;
2545   return jresult;
2546 }
2547
2548
2549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2550   void * jresult ;
2551   floatp *arg1 = (floatp *) 0 ;
2552   float *result = 0 ;
2553
2554   arg1 = (floatp *)jarg1;
2555   {
2556     try {
2557       result = (float *)floatp_cast(arg1);
2558     } catch (std::out_of_range& e) {
2559       {
2560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2561       };
2562     } catch (std::exception& e) {
2563       {
2564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2565       };
2566     } catch (...) {
2567       {
2568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2569       };
2570     }
2571   }
2572   jresult = (void *)result;
2573   return jresult;
2574 }
2575
2576
2577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2578   void * jresult ;
2579   float *arg1 = (float *) 0 ;
2580   floatp *result = 0 ;
2581
2582   arg1 = (float *)jarg1;
2583   {
2584     try {
2585       result = (floatp *)floatp_frompointer(arg1);
2586     } catch (std::out_of_range& e) {
2587       {
2588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2589       };
2590     } catch (std::exception& e) {
2591       {
2592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2593       };
2594     } catch (...) {
2595       {
2596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2597       };
2598     }
2599   }
2600   jresult = (void *)result;
2601   return jresult;
2602 }
2603
2604
2605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2606   void * jresult ;
2607   intp *result = 0 ;
2608
2609   {
2610     try {
2611       result = (intp *)new_intp();
2612     } catch (std::out_of_range& e) {
2613       {
2614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2615       };
2616     } catch (std::exception& e) {
2617       {
2618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2619       };
2620     } catch (...) {
2621       {
2622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2623       };
2624     }
2625   }
2626   jresult = (void *)result;
2627   return jresult;
2628 }
2629
2630
2631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2632   intp *arg1 = (intp *) 0 ;
2633
2634   arg1 = (intp *)jarg1;
2635   {
2636     try {
2637       delete_intp(arg1);
2638     } catch (std::out_of_range& e) {
2639       {
2640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2641       };
2642     } catch (std::exception& e) {
2643       {
2644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2645       };
2646     } catch (...) {
2647       {
2648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2649       };
2650     }
2651   }
2652 }
2653
2654
2655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2656   intp *arg1 = (intp *) 0 ;
2657   int arg2 ;
2658
2659   arg1 = (intp *)jarg1;
2660   arg2 = (int)jarg2;
2661   {
2662     try {
2663       intp_assign(arg1,arg2);
2664     } catch (std::out_of_range& e) {
2665       {
2666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2667       };
2668     } catch (std::exception& e) {
2669       {
2670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2671       };
2672     } catch (...) {
2673       {
2674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2675       };
2676     }
2677   }
2678 }
2679
2680
2681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2682   int jresult ;
2683   intp *arg1 = (intp *) 0 ;
2684   int result;
2685
2686   arg1 = (intp *)jarg1;
2687   {
2688     try {
2689       result = (int)intp_value(arg1);
2690     } catch (std::out_of_range& e) {
2691       {
2692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2693       };
2694     } catch (std::exception& e) {
2695       {
2696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2697       };
2698     } catch (...) {
2699       {
2700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2701       };
2702     }
2703   }
2704   jresult = result;
2705   return jresult;
2706 }
2707
2708
2709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2710   void * jresult ;
2711   intp *arg1 = (intp *) 0 ;
2712   int *result = 0 ;
2713
2714   arg1 = (intp *)jarg1;
2715   {
2716     try {
2717       result = (int *)intp_cast(arg1);
2718     } catch (std::out_of_range& e) {
2719       {
2720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2721       };
2722     } catch (std::exception& e) {
2723       {
2724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2725       };
2726     } catch (...) {
2727       {
2728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2729       };
2730     }
2731   }
2732   jresult = (void *)result;
2733   return jresult;
2734 }
2735
2736
2737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2738   void * jresult ;
2739   int *arg1 = (int *) 0 ;
2740   intp *result = 0 ;
2741
2742   arg1 = (int *)jarg1;
2743   {
2744     try {
2745       result = (intp *)intp_frompointer(arg1);
2746     } catch (std::out_of_range& e) {
2747       {
2748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2749       };
2750     } catch (std::exception& e) {
2751       {
2752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2753       };
2754     } catch (...) {
2755       {
2756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2757       };
2758     }
2759   }
2760   jresult = (void *)result;
2761   return jresult;
2762 }
2763
2764
2765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2766   void * jresult ;
2767   doublep *result = 0 ;
2768
2769   {
2770     try {
2771       result = (doublep *)new_doublep();
2772     } catch (std::out_of_range& e) {
2773       {
2774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2775       };
2776     } catch (std::exception& e) {
2777       {
2778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2779       };
2780     } catch (...) {
2781       {
2782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2783       };
2784     }
2785   }
2786   jresult = (void *)result;
2787   return jresult;
2788 }
2789
2790
2791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2792   doublep *arg1 = (doublep *) 0 ;
2793
2794   arg1 = (doublep *)jarg1;
2795   {
2796     try {
2797       delete_doublep(arg1);
2798     } catch (std::out_of_range& e) {
2799       {
2800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2801       };
2802     } catch (std::exception& e) {
2803       {
2804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2805       };
2806     } catch (...) {
2807       {
2808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2809       };
2810     }
2811   }
2812 }
2813
2814
2815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2816   doublep *arg1 = (doublep *) 0 ;
2817   double arg2 ;
2818
2819   arg1 = (doublep *)jarg1;
2820   arg2 = (double)jarg2;
2821   {
2822     try {
2823       doublep_assign(arg1,arg2);
2824     } catch (std::out_of_range& e) {
2825       {
2826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2827       };
2828     } catch (std::exception& e) {
2829       {
2830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2831       };
2832     } catch (...) {
2833       {
2834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2835       };
2836     }
2837   }
2838 }
2839
2840
2841 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2842   double jresult ;
2843   doublep *arg1 = (doublep *) 0 ;
2844   double result;
2845
2846   arg1 = (doublep *)jarg1;
2847   {
2848     try {
2849       result = (double)doublep_value(arg1);
2850     } catch (std::out_of_range& e) {
2851       {
2852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2853       };
2854     } catch (std::exception& e) {
2855       {
2856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2857       };
2858     } catch (...) {
2859       {
2860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2861       };
2862     }
2863   }
2864   jresult = result;
2865   return jresult;
2866 }
2867
2868
2869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2870   void * jresult ;
2871   doublep *arg1 = (doublep *) 0 ;
2872   double *result = 0 ;
2873
2874   arg1 = (doublep *)jarg1;
2875   {
2876     try {
2877       result = (double *)doublep_cast(arg1);
2878     } catch (std::out_of_range& e) {
2879       {
2880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2881       };
2882     } catch (std::exception& e) {
2883       {
2884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2885       };
2886     } catch (...) {
2887       {
2888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2889       };
2890     }
2891   }
2892   jresult = (void *)result;
2893   return jresult;
2894 }
2895
2896
2897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2898   void * jresult ;
2899   double *arg1 = (double *) 0 ;
2900   doublep *result = 0 ;
2901
2902   arg1 = (double *)jarg1;
2903   {
2904     try {
2905       result = (doublep *)doublep_frompointer(arg1);
2906     } catch (std::out_of_range& e) {
2907       {
2908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2909       };
2910     } catch (std::exception& e) {
2911       {
2912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2913       };
2914     } catch (...) {
2915       {
2916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2917       };
2918     }
2919   }
2920   jresult = (void *)result;
2921   return jresult;
2922 }
2923
2924
2925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2926   void * jresult ;
2927   uintp *result = 0 ;
2928
2929   {
2930     try {
2931       result = (uintp *)new_uintp();
2932     } catch (std::out_of_range& e) {
2933       {
2934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2935       };
2936     } catch (std::exception& e) {
2937       {
2938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2939       };
2940     } catch (...) {
2941       {
2942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2943       };
2944     }
2945   }
2946   jresult = (void *)result;
2947   return jresult;
2948 }
2949
2950
2951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2952   uintp *arg1 = (uintp *) 0 ;
2953
2954   arg1 = (uintp *)jarg1;
2955   {
2956     try {
2957       delete_uintp(arg1);
2958     } catch (std::out_of_range& e) {
2959       {
2960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2961       };
2962     } catch (std::exception& e) {
2963       {
2964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2965       };
2966     } catch (...) {
2967       {
2968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2969       };
2970     }
2971   }
2972 }
2973
2974
2975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2976   uintp *arg1 = (uintp *) 0 ;
2977   unsigned int arg2 ;
2978
2979   arg1 = (uintp *)jarg1;
2980   arg2 = (unsigned int)jarg2;
2981   {
2982     try {
2983       uintp_assign(arg1,arg2);
2984     } catch (std::out_of_range& e) {
2985       {
2986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2987       };
2988     } catch (std::exception& e) {
2989       {
2990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2991       };
2992     } catch (...) {
2993       {
2994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2995       };
2996     }
2997   }
2998 }
2999
3000
3001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3002   unsigned int jresult ;
3003   uintp *arg1 = (uintp *) 0 ;
3004   unsigned int result;
3005
3006   arg1 = (uintp *)jarg1;
3007   {
3008     try {
3009       result = (unsigned int)uintp_value(arg1);
3010     } catch (std::out_of_range& e) {
3011       {
3012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3013       };
3014     } catch (std::exception& e) {
3015       {
3016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3017       };
3018     } catch (...) {
3019       {
3020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3021       };
3022     }
3023   }
3024   jresult = result;
3025   return jresult;
3026 }
3027
3028
3029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3030   void * jresult ;
3031   uintp *arg1 = (uintp *) 0 ;
3032   unsigned int *result = 0 ;
3033
3034   arg1 = (uintp *)jarg1;
3035   {
3036     try {
3037       result = (unsigned int *)uintp_cast(arg1);
3038     } catch (std::out_of_range& e) {
3039       {
3040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3041       };
3042     } catch (std::exception& e) {
3043       {
3044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3045       };
3046     } catch (...) {
3047       {
3048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3049       };
3050     }
3051   }
3052   jresult = (void *)result;
3053   return jresult;
3054 }
3055
3056
3057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3058   void * jresult ;
3059   unsigned int *arg1 = (unsigned int *) 0 ;
3060   uintp *result = 0 ;
3061
3062   arg1 = (unsigned int *)jarg1;
3063   {
3064     try {
3065       result = (uintp *)uintp_frompointer(arg1);
3066     } catch (std::out_of_range& e) {
3067       {
3068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3069       };
3070     } catch (std::exception& e) {
3071       {
3072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3073       };
3074     } catch (...) {
3075       {
3076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3077       };
3078     }
3079   }
3080   jresult = (void *)result;
3081   return jresult;
3082 }
3083
3084
3085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3086   void * jresult ;
3087   ushortp *result = 0 ;
3088
3089   {
3090     try {
3091       result = (ushortp *)new_ushortp();
3092     } catch (std::out_of_range& e) {
3093       {
3094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3095       };
3096     } catch (std::exception& e) {
3097       {
3098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3099       };
3100     } catch (...) {
3101       {
3102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3103       };
3104     }
3105   }
3106   jresult = (void *)result;
3107   return jresult;
3108 }
3109
3110
3111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3112   ushortp *arg1 = (ushortp *) 0 ;
3113
3114   arg1 = (ushortp *)jarg1;
3115   {
3116     try {
3117       delete_ushortp(arg1);
3118     } catch (std::out_of_range& e) {
3119       {
3120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3121       };
3122     } catch (std::exception& e) {
3123       {
3124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3125       };
3126     } catch (...) {
3127       {
3128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3129       };
3130     }
3131   }
3132 }
3133
3134
3135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3136   ushortp *arg1 = (ushortp *) 0 ;
3137   unsigned short arg2 ;
3138
3139   arg1 = (ushortp *)jarg1;
3140   arg2 = (unsigned short)jarg2;
3141   {
3142     try {
3143       ushortp_assign(arg1,arg2);
3144     } catch (std::out_of_range& e) {
3145       {
3146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3147       };
3148     } catch (std::exception& e) {
3149       {
3150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3151       };
3152     } catch (...) {
3153       {
3154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3155       };
3156     }
3157   }
3158 }
3159
3160
3161 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3162   unsigned short jresult ;
3163   ushortp *arg1 = (ushortp *) 0 ;
3164   unsigned short result;
3165
3166   arg1 = (ushortp *)jarg1;
3167   {
3168     try {
3169       result = (unsigned short)ushortp_value(arg1);
3170     } catch (std::out_of_range& e) {
3171       {
3172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3173       };
3174     } catch (std::exception& e) {
3175       {
3176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3177       };
3178     } catch (...) {
3179       {
3180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3181       };
3182     }
3183   }
3184   jresult = result;
3185   return jresult;
3186 }
3187
3188
3189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3190   void * jresult ;
3191   ushortp *arg1 = (ushortp *) 0 ;
3192   unsigned short *result = 0 ;
3193
3194   arg1 = (ushortp *)jarg1;
3195   {
3196     try {
3197       result = (unsigned short *)ushortp_cast(arg1);
3198     } catch (std::out_of_range& e) {
3199       {
3200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3201       };
3202     } catch (std::exception& e) {
3203       {
3204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3205       };
3206     } catch (...) {
3207       {
3208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3209       };
3210     }
3211   }
3212   jresult = (void *)result;
3213   return jresult;
3214 }
3215
3216
3217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3218   void * jresult ;
3219   unsigned short *arg1 = (unsigned short *) 0 ;
3220   ushortp *result = 0 ;
3221
3222   arg1 = (unsigned short *)jarg1;
3223   {
3224     try {
3225       result = (ushortp *)ushortp_frompointer(arg1);
3226     } catch (std::out_of_range& e) {
3227       {
3228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3229       };
3230     } catch (std::exception& e) {
3231       {
3232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3233       };
3234     } catch (...) {
3235       {
3236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3237       };
3238     }
3239   }
3240   jresult = (void *)result;
3241   return jresult;
3242 }
3243
3244
3245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3246   unsigned int jresult ;
3247   int arg1 ;
3248   unsigned int result;
3249
3250   arg1 = (int)jarg1;
3251   {
3252     try {
3253       result = (unsigned int)int_to_uint(arg1);
3254     } catch (std::out_of_range& e) {
3255       {
3256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3257       };
3258     } catch (std::exception& e) {
3259       {
3260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3261       };
3262     } catch (...) {
3263       {
3264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3265       };
3266     }
3267   }
3268   jresult = result;
3269   return jresult;
3270 }
3271
3272
3273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3274   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3275
3276   arg1 = (Dali::RefObject *)jarg1;
3277   {
3278     try {
3279       (arg1)->Reference();
3280     } catch (std::out_of_range& e) {
3281       {
3282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3283       };
3284     } catch (std::exception& e) {
3285       {
3286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3287       };
3288     } catch (...) {
3289       {
3290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3291       };
3292     }
3293   }
3294 }
3295
3296
3297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3298   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3299
3300   arg1 = (Dali::RefObject *)jarg1;
3301   {
3302     try {
3303       (arg1)->Unreference();
3304     } catch (std::out_of_range& e) {
3305       {
3306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3307       };
3308     } catch (std::exception& e) {
3309       {
3310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3311       };
3312     } catch (...) {
3313       {
3314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3315       };
3316     }
3317   }
3318 }
3319
3320
3321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3322   int jresult ;
3323   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3324   int result;
3325
3326   arg1 = (Dali::RefObject *)jarg1;
3327   {
3328     try {
3329       result = (int)(arg1)->ReferenceCount();
3330     } catch (std::out_of_range& e) {
3331       {
3332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3333       };
3334     } catch (std::exception& e) {
3335       {
3336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3337       };
3338     } catch (...) {
3339       {
3340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3341       };
3342     }
3343   }
3344   jresult = result;
3345   return jresult;
3346 }
3347
3348
3349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3350   void * jresult ;
3351   Dali::Any *result = 0 ;
3352
3353   {
3354     try {
3355       result = (Dali::Any *)new Dali::Any();
3356     } catch (std::out_of_range& e) {
3357       {
3358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3359       };
3360     } catch (std::exception& e) {
3361       {
3362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3363       };
3364     } catch (...) {
3365       {
3366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3367       };
3368     }
3369   }
3370   jresult = (void *)result;
3371   return jresult;
3372 }
3373
3374
3375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3376   Dali::Any *arg1 = (Dali::Any *) 0 ;
3377
3378   arg1 = (Dali::Any *)jarg1;
3379   {
3380     try {
3381       delete arg1;
3382     } catch (std::out_of_range& e) {
3383       {
3384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3385       };
3386     } catch (std::exception& e) {
3387       {
3388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3389       };
3390     } catch (...) {
3391       {
3392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3393       };
3394     }
3395   }
3396 }
3397
3398
3399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3400   char *arg1 = (char *) 0 ;
3401
3402   arg1 = (char *)jarg1;
3403   {
3404     try {
3405       Dali::Any::AssertAlways((char const *)arg1);
3406     } catch (std::out_of_range& e) {
3407       {
3408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3409       };
3410     } catch (std::exception& e) {
3411       {
3412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3413       };
3414     } catch (...) {
3415       {
3416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3417       };
3418     }
3419   }
3420 }
3421
3422
3423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3424   void * jresult ;
3425   Dali::Any *arg1 = 0 ;
3426   Dali::Any *result = 0 ;
3427
3428   arg1 = (Dali::Any *)jarg1;
3429   if (!arg1) {
3430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3431     return 0;
3432   }
3433   {
3434     try {
3435       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3436     } catch (std::out_of_range& e) {
3437       {
3438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3439       };
3440     } catch (std::exception& e) {
3441       {
3442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3443       };
3444     } catch (...) {
3445       {
3446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3447       };
3448     }
3449   }
3450   jresult = (void *)result;
3451   return jresult;
3452 }
3453
3454
3455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3456   void * jresult ;
3457   Dali::Any *arg1 = (Dali::Any *) 0 ;
3458   Dali::Any *arg2 = 0 ;
3459   Dali::Any *result = 0 ;
3460
3461   arg1 = (Dali::Any *)jarg1;
3462   arg2 = (Dali::Any *)jarg2;
3463   if (!arg2) {
3464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3465     return 0;
3466   }
3467   {
3468     try {
3469       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3470     } catch (std::out_of_range& e) {
3471       {
3472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3473       };
3474     } catch (std::exception& e) {
3475       {
3476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3477       };
3478     } catch (...) {
3479       {
3480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3481       };
3482     }
3483   }
3484   jresult = (void *)result;
3485   return jresult;
3486 }
3487
3488
3489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3490   void * jresult ;
3491   Dali::Any *arg1 = (Dali::Any *) 0 ;
3492   std::type_info *result = 0 ;
3493
3494   arg1 = (Dali::Any *)jarg1;
3495   {
3496     try {
3497       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3498     } catch (std::out_of_range& e) {
3499       {
3500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3501       };
3502     } catch (std::exception& e) {
3503       {
3504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3505       };
3506     } catch (...) {
3507       {
3508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3509       };
3510     }
3511   }
3512   jresult = (void *)result;
3513   return jresult;
3514 }
3515
3516
3517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3518   unsigned int jresult ;
3519   Dali::Any *arg1 = (Dali::Any *) 0 ;
3520   bool result;
3521
3522   arg1 = (Dali::Any *)jarg1;
3523   {
3524     try {
3525       result = (bool)((Dali::Any const *)arg1)->Empty();
3526     } catch (std::out_of_range& e) {
3527       {
3528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3529       };
3530     } catch (std::exception& e) {
3531       {
3532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3533       };
3534     } catch (...) {
3535       {
3536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3537       };
3538     }
3539   }
3540   jresult = result;
3541   return jresult;
3542 }
3543
3544
3545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3546   void * jresult ;
3547   std::type_info *arg1 = 0 ;
3548   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3549   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3550   Dali::Any::AnyContainerBase *result = 0 ;
3551
3552   arg1 = (std::type_info *)jarg1;
3553   if (!arg1) {
3554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3555     return 0;
3556   }
3557   arg2 = (Dali::Any::CloneFunc)jarg2;
3558   arg3 = (Dali::Any::DeleteFunc)jarg3;
3559   {
3560     try {
3561       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3562     } catch (std::out_of_range& e) {
3563       {
3564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3565       };
3566     } catch (std::exception& e) {
3567       {
3568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3569       };
3570     } catch (...) {
3571       {
3572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3573       };
3574     }
3575   }
3576   jresult = (void *)result;
3577   return jresult;
3578 }
3579
3580
3581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3582   void * jresult ;
3583   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3584   std::type_info *result = 0 ;
3585
3586   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3587   {
3588     try {
3589       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3590     } catch (std::out_of_range& e) {
3591       {
3592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3593       };
3594     } catch (std::exception& e) {
3595       {
3596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3597       };
3598     } catch (...) {
3599       {
3600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3601       };
3602     }
3603   }
3604   jresult = (void *)result;
3605   return jresult;
3606 }
3607
3608
3609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3610   void * jresult ;
3611   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3612   ::std::type_info *result = 0 ;
3613
3614   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3615   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3616   jresult = (void *)result;
3617   return jresult;
3618 }
3619
3620
3621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3622   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3623   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3624
3625   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3626   arg2 = (Dali::Any::CloneFunc)jarg2;
3627   if (arg1) (arg1)->mCloneFunc = arg2;
3628 }
3629
3630
3631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3632   void * jresult ;
3633   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3634   Dali::Any::CloneFunc result;
3635
3636   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3637   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3638   jresult = (void *)result;
3639   return jresult;
3640 }
3641
3642
3643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3644   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3645   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3646
3647   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3648   arg2 = (Dali::Any::DeleteFunc)jarg2;
3649   if (arg1) (arg1)->mDeleteFunc = arg2;
3650 }
3651
3652
3653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3654   void * jresult ;
3655   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3656   Dali::Any::DeleteFunc result;
3657
3658   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3659   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3660   jresult = (void *)result;
3661   return jresult;
3662 }
3663
3664
3665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3666   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3667
3668   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3669   {
3670     try {
3671       delete arg1;
3672     } catch (std::out_of_range& e) {
3673       {
3674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3675       };
3676     } catch (std::exception& e) {
3677       {
3678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3679       };
3680     } catch (...) {
3681       {
3682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3683       };
3684     }
3685   }
3686 }
3687
3688
3689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3690   Dali::Any *arg1 = (Dali::Any *) 0 ;
3691   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3692
3693   arg1 = (Dali::Any *)jarg1;
3694   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3695   if (arg1) (arg1)->mContainer = arg2;
3696 }
3697
3698
3699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3700   void * jresult ;
3701   Dali::Any *arg1 = (Dali::Any *) 0 ;
3702   Dali::Any::AnyContainerBase *result = 0 ;
3703
3704   arg1 = (Dali::Any *)jarg1;
3705   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3706   jresult = (void *)result;
3707   return jresult;
3708 }
3709
3710
3711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3712   char *arg1 = (char *) 0 ;
3713   char *arg2 = (char *) 0 ;
3714
3715   arg1 = (char *)jarg1;
3716   arg2 = (char *)jarg2;
3717   {
3718     try {
3719       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3720     } catch (std::out_of_range& e) {
3721       {
3722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3723       };
3724     } catch (std::exception& e) {
3725       {
3726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3727       };
3728     } catch (...) {
3729       {
3730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3731       };
3732     }
3733   }
3734 }
3735
3736
3737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3738   void * jresult ;
3739   char *arg1 = (char *) 0 ;
3740   char *arg2 = (char *) 0 ;
3741   Dali::DaliException *result = 0 ;
3742
3743   arg1 = (char *)jarg1;
3744   arg2 = (char *)jarg2;
3745   {
3746     try {
3747       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3748     } catch (std::out_of_range& e) {
3749       {
3750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3751       };
3752     } catch (std::exception& e) {
3753       {
3754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3755       };
3756     } catch (...) {
3757       {
3758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3759       };
3760     }
3761   }
3762   jresult = (void *)result;
3763   return jresult;
3764 }
3765
3766
3767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3768   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3769   char *arg2 = (char *) 0 ;
3770
3771   arg1 = (Dali::DaliException *)jarg1;
3772   arg2 = (char *)jarg2;
3773   {
3774     if (arg2) {
3775       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3776       strcpy((char *)arg1->location, (const char *)arg2);
3777     } else {
3778       arg1->location = 0;
3779     }
3780   }
3781 }
3782
3783
3784 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3785   char * jresult ;
3786   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3787   char *result = 0 ;
3788
3789   arg1 = (Dali::DaliException *)jarg1;
3790   result = (char *) ((arg1)->location);
3791   jresult = SWIG_csharp_string_callback((const char *)result);
3792   return jresult;
3793 }
3794
3795
3796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3797   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3798   char *arg2 = (char *) 0 ;
3799
3800   arg1 = (Dali::DaliException *)jarg1;
3801   arg2 = (char *)jarg2;
3802   {
3803     if (arg2) {
3804       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3805       strcpy((char *)arg1->condition, (const char *)arg2);
3806     } else {
3807       arg1->condition = 0;
3808     }
3809   }
3810 }
3811
3812
3813 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3814   char * jresult ;
3815   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3816   char *result = 0 ;
3817
3818   arg1 = (Dali::DaliException *)jarg1;
3819   result = (char *) ((arg1)->condition);
3820   jresult = SWIG_csharp_string_callback((const char *)result);
3821   return jresult;
3822 }
3823
3824
3825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3826   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3827
3828   arg1 = (Dali::DaliException *)jarg1;
3829   {
3830     try {
3831       delete arg1;
3832     } catch (std::out_of_range& e) {
3833       {
3834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3835       };
3836     } catch (std::exception& e) {
3837       {
3838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3839       };
3840     } catch (...) {
3841       {
3842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3843       };
3844     }
3845   }
3846 }
3847
3848
3849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3850   void * jresult ;
3851   Dali::Vector2 *result = 0 ;
3852
3853   {
3854     try {
3855       result = (Dali::Vector2 *)new Dali::Vector2();
3856     } catch (std::out_of_range& e) {
3857       {
3858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3859       };
3860     } catch (std::exception& e) {
3861       {
3862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3863       };
3864     } catch (...) {
3865       {
3866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3867       };
3868     }
3869   }
3870   jresult = (void *)result;
3871   return jresult;
3872 }
3873
3874
3875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3876   void * jresult ;
3877   float arg1 ;
3878   float arg2 ;
3879   Dali::Vector2 *result = 0 ;
3880
3881   arg1 = (float)jarg1;
3882   arg2 = (float)jarg2;
3883   {
3884     try {
3885       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3886     } catch (std::out_of_range& e) {
3887       {
3888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3889       };
3890     } catch (std::exception& e) {
3891       {
3892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3893       };
3894     } catch (...) {
3895       {
3896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3897       };
3898     }
3899   }
3900   jresult = (void *)result;
3901   return jresult;
3902 }
3903
3904
3905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3906   void * jresult ;
3907   float *arg1 = (float *) 0 ;
3908   Dali::Vector2 *result = 0 ;
3909
3910   arg1 = jarg1;
3911   {
3912     try {
3913       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3914     } catch (std::out_of_range& e) {
3915       {
3916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3917       };
3918     } catch (std::exception& e) {
3919       {
3920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3921       };
3922     } catch (...) {
3923       {
3924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3925       };
3926     }
3927   }
3928   jresult = (void *)result;
3929
3930
3931   return jresult;
3932 }
3933
3934
3935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3936   void * jresult ;
3937   Dali::Vector3 *arg1 = 0 ;
3938   Dali::Vector2 *result = 0 ;
3939
3940   arg1 = (Dali::Vector3 *)jarg1;
3941   if (!arg1) {
3942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3943     return 0;
3944   }
3945   {
3946     try {
3947       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3948     } catch (std::out_of_range& e) {
3949       {
3950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3951       };
3952     } catch (std::exception& e) {
3953       {
3954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3955       };
3956     } catch (...) {
3957       {
3958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3959       };
3960     }
3961   }
3962   jresult = (void *)result;
3963   return jresult;
3964 }
3965
3966
3967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3968   void * jresult ;
3969   Dali::Vector4 *arg1 = 0 ;
3970   Dali::Vector2 *result = 0 ;
3971
3972   arg1 = (Dali::Vector4 *)jarg1;
3973   if (!arg1) {
3974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3975     return 0;
3976   }
3977   {
3978     try {
3979       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3980     } catch (std::out_of_range& e) {
3981       {
3982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3983       };
3984     } catch (std::exception& e) {
3985       {
3986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3987       };
3988     } catch (...) {
3989       {
3990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3991       };
3992     }
3993   }
3994   jresult = (void *)result;
3995   return jresult;
3996 }
3997
3998
3999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4000   void * jresult ;
4001   Dali::Vector2 *result = 0 ;
4002
4003   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4004   jresult = (void *)result;
4005   return jresult;
4006 }
4007
4008
4009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4010   void * jresult ;
4011   Dali::Vector2 *result = 0 ;
4012
4013   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4014   jresult = (void *)result;
4015   return jresult;
4016 }
4017
4018
4019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4020   void * jresult ;
4021   Dali::Vector2 *result = 0 ;
4022
4023   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4024   jresult = (void *)result;
4025   return jresult;
4026 }
4027
4028
4029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4030   void * jresult ;
4031   Dali::Vector2 *result = 0 ;
4032
4033   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4034   jresult = (void *)result;
4035   return jresult;
4036 }
4037
4038
4039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4040   void * jresult ;
4041   Dali::Vector2 *result = 0 ;
4042
4043   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4044   jresult = (void *)result;
4045   return jresult;
4046 }
4047
4048
4049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4050   void * jresult ;
4051   Dali::Vector2 *result = 0 ;
4052
4053   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4054   jresult = (void *)result;
4055   return jresult;
4056 }
4057
4058
4059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4060   void * jresult ;
4061   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4062   float *arg2 = (float *) 0 ;
4063   Dali::Vector2 *result = 0 ;
4064
4065   arg1 = (Dali::Vector2 *)jarg1;
4066   arg2 = jarg2;
4067   {
4068     try {
4069       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4070     } catch (std::out_of_range& e) {
4071       {
4072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4073       };
4074     } catch (std::exception& e) {
4075       {
4076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4077       };
4078     } catch (...) {
4079       {
4080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4081       };
4082     }
4083   }
4084   jresult = (void *)result;
4085
4086
4087   return jresult;
4088 }
4089
4090
4091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4092   void * jresult ;
4093   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4094   Dali::Vector3 *arg2 = 0 ;
4095   Dali::Vector2 *result = 0 ;
4096
4097   arg1 = (Dali::Vector2 *)jarg1;
4098   arg2 = (Dali::Vector3 *)jarg2;
4099   if (!arg2) {
4100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4101     return 0;
4102   }
4103   {
4104     try {
4105       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4106     } catch (std::out_of_range& e) {
4107       {
4108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4109       };
4110     } catch (std::exception& e) {
4111       {
4112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4113       };
4114     } catch (...) {
4115       {
4116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4117       };
4118     }
4119   }
4120   jresult = (void *)result;
4121   return jresult;
4122 }
4123
4124
4125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4126   void * jresult ;
4127   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4128   Dali::Vector4 *arg2 = 0 ;
4129   Dali::Vector2 *result = 0 ;
4130
4131   arg1 = (Dali::Vector2 *)jarg1;
4132   arg2 = (Dali::Vector4 *)jarg2;
4133   if (!arg2) {
4134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4135     return 0;
4136   }
4137   {
4138     try {
4139       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4140     } catch (std::out_of_range& e) {
4141       {
4142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4143       };
4144     } catch (std::exception& e) {
4145       {
4146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4147       };
4148     } catch (...) {
4149       {
4150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4151       };
4152     }
4153   }
4154   jresult = (void *)result;
4155   return jresult;
4156 }
4157
4158
4159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4160   void * jresult ;
4161   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4162   Dali::Vector2 *arg2 = 0 ;
4163   Dali::Vector2 result;
4164
4165   arg1 = (Dali::Vector2 *)jarg1;
4166   arg2 = (Dali::Vector2 *)jarg2;
4167   if (!arg2) {
4168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4169     return 0;
4170   }
4171   {
4172     try {
4173       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4174     } catch (std::out_of_range& e) {
4175       {
4176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4177       };
4178     } catch (std::exception& e) {
4179       {
4180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4181       };
4182     } catch (...) {
4183       {
4184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4185       };
4186     }
4187   }
4188   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4189   return jresult;
4190 }
4191
4192
4193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4194   void * jresult ;
4195   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4196   Dali::Vector2 *arg2 = 0 ;
4197   Dali::Vector2 *result = 0 ;
4198
4199   arg1 = (Dali::Vector2 *)jarg1;
4200   arg2 = (Dali::Vector2 *)jarg2;
4201   if (!arg2) {
4202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4203     return 0;
4204   }
4205   {
4206     try {
4207       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4208     } catch (std::out_of_range& e) {
4209       {
4210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4211       };
4212     } catch (std::exception& e) {
4213       {
4214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4215       };
4216     } catch (...) {
4217       {
4218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4219       };
4220     }
4221   }
4222   jresult = (void *)result;
4223   return jresult;
4224 }
4225
4226
4227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4228   void * jresult ;
4229   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4230   Dali::Vector2 *arg2 = 0 ;
4231   Dali::Vector2 result;
4232
4233   arg1 = (Dali::Vector2 *)jarg1;
4234   arg2 = (Dali::Vector2 *)jarg2;
4235   if (!arg2) {
4236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4237     return 0;
4238   }
4239   {
4240     try {
4241       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4242     } catch (std::out_of_range& e) {
4243       {
4244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4245       };
4246     } catch (std::exception& e) {
4247       {
4248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4249       };
4250     } catch (...) {
4251       {
4252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4253       };
4254     }
4255   }
4256   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4257   return jresult;
4258 }
4259
4260
4261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4262   void * jresult ;
4263   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4264   Dali::Vector2 *arg2 = 0 ;
4265   Dali::Vector2 *result = 0 ;
4266
4267   arg1 = (Dali::Vector2 *)jarg1;
4268   arg2 = (Dali::Vector2 *)jarg2;
4269   if (!arg2) {
4270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4271     return 0;
4272   }
4273   {
4274     try {
4275       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4276     } catch (std::out_of_range& e) {
4277       {
4278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4279       };
4280     } catch (std::exception& e) {
4281       {
4282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4283       };
4284     } catch (...) {
4285       {
4286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4287       };
4288     }
4289   }
4290   jresult = (void *)result;
4291   return jresult;
4292 }
4293
4294
4295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4296   void * jresult ;
4297   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4298   Dali::Vector2 *arg2 = 0 ;
4299   Dali::Vector2 result;
4300
4301   arg1 = (Dali::Vector2 *)jarg1;
4302   arg2 = (Dali::Vector2 *)jarg2;
4303   if (!arg2) {
4304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4305     return 0;
4306   }
4307   {
4308     try {
4309       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4310     } catch (std::out_of_range& e) {
4311       {
4312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4313       };
4314     } catch (std::exception& e) {
4315       {
4316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4317       };
4318     } catch (...) {
4319       {
4320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4321       };
4322     }
4323   }
4324   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4325   return jresult;
4326 }
4327
4328
4329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4330   void * jresult ;
4331   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4332   float arg2 ;
4333   Dali::Vector2 result;
4334
4335   arg1 = (Dali::Vector2 *)jarg1;
4336   arg2 = (float)jarg2;
4337   {
4338     try {
4339       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4340     } catch (std::out_of_range& e) {
4341       {
4342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4343       };
4344     } catch (std::exception& e) {
4345       {
4346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4347       };
4348     } catch (...) {
4349       {
4350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4351       };
4352     }
4353   }
4354   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4355   return jresult;
4356 }
4357
4358
4359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4360   void * jresult ;
4361   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4362   Dali::Vector2 *arg2 = 0 ;
4363   Dali::Vector2 *result = 0 ;
4364
4365   arg1 = (Dali::Vector2 *)jarg1;
4366   arg2 = (Dali::Vector2 *)jarg2;
4367   if (!arg2) {
4368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4369     return 0;
4370   }
4371   {
4372     try {
4373       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4374     } catch (std::out_of_range& e) {
4375       {
4376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4377       };
4378     } catch (std::exception& e) {
4379       {
4380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4381       };
4382     } catch (...) {
4383       {
4384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4385       };
4386     }
4387   }
4388   jresult = (void *)result;
4389   return jresult;
4390 }
4391
4392
4393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4394   void * jresult ;
4395   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4396   float arg2 ;
4397   Dali::Vector2 *result = 0 ;
4398
4399   arg1 = (Dali::Vector2 *)jarg1;
4400   arg2 = (float)jarg2;
4401   {
4402     try {
4403       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4404     } catch (std::out_of_range& e) {
4405       {
4406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4407       };
4408     } catch (std::exception& e) {
4409       {
4410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4411       };
4412     } catch (...) {
4413       {
4414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4415       };
4416     }
4417   }
4418   jresult = (void *)result;
4419   return jresult;
4420 }
4421
4422
4423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4424   void * jresult ;
4425   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4426   Dali::Vector2 *arg2 = 0 ;
4427   Dali::Vector2 result;
4428
4429   arg1 = (Dali::Vector2 *)jarg1;
4430   arg2 = (Dali::Vector2 *)jarg2;
4431   if (!arg2) {
4432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4433     return 0;
4434   }
4435   {
4436     try {
4437       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4438     } catch (std::out_of_range& e) {
4439       {
4440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4441       };
4442     } catch (std::exception& e) {
4443       {
4444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4445       };
4446     } catch (...) {
4447       {
4448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4449       };
4450     }
4451   }
4452   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4453   return jresult;
4454 }
4455
4456
4457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4458   void * jresult ;
4459   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4460   float arg2 ;
4461   Dali::Vector2 result;
4462
4463   arg1 = (Dali::Vector2 *)jarg1;
4464   arg2 = (float)jarg2;
4465   {
4466     try {
4467       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4468     } catch (std::out_of_range& e) {
4469       {
4470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4471       };
4472     } catch (std::exception& e) {
4473       {
4474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4475       };
4476     } catch (...) {
4477       {
4478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4479       };
4480     }
4481   }
4482   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4483   return jresult;
4484 }
4485
4486
4487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4488   void * jresult ;
4489   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4490   Dali::Vector2 *arg2 = 0 ;
4491   Dali::Vector2 *result = 0 ;
4492
4493   arg1 = (Dali::Vector2 *)jarg1;
4494   arg2 = (Dali::Vector2 *)jarg2;
4495   if (!arg2) {
4496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4497     return 0;
4498   }
4499   {
4500     try {
4501       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4502     } catch (std::out_of_range& e) {
4503       {
4504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4505       };
4506     } catch (std::exception& e) {
4507       {
4508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4509       };
4510     } catch (...) {
4511       {
4512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4513       };
4514     }
4515   }
4516   jresult = (void *)result;
4517   return jresult;
4518 }
4519
4520
4521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4522   void * jresult ;
4523   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4524   float arg2 ;
4525   Dali::Vector2 *result = 0 ;
4526
4527   arg1 = (Dali::Vector2 *)jarg1;
4528   arg2 = (float)jarg2;
4529   {
4530     try {
4531       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4532     } catch (std::out_of_range& e) {
4533       {
4534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4535       };
4536     } catch (std::exception& e) {
4537       {
4538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4539       };
4540     } catch (...) {
4541       {
4542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4543       };
4544     }
4545   }
4546   jresult = (void *)result;
4547   return jresult;
4548 }
4549
4550
4551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4552   void * jresult ;
4553   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4554   Dali::Vector2 result;
4555
4556   arg1 = (Dali::Vector2 *)jarg1;
4557   {
4558     try {
4559       result = ((Dali::Vector2 const *)arg1)->operator -();
4560     } catch (std::out_of_range& e) {
4561       {
4562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4563       };
4564     } catch (std::exception& e) {
4565       {
4566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4567       };
4568     } catch (...) {
4569       {
4570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4571       };
4572     }
4573   }
4574   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4575   return jresult;
4576 }
4577
4578
4579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4580   unsigned int jresult ;
4581   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4582   Dali::Vector2 *arg2 = 0 ;
4583   bool result;
4584
4585   arg1 = (Dali::Vector2 *)jarg1;
4586   arg2 = (Dali::Vector2 *)jarg2;
4587   if (!arg2) {
4588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4589     return 0;
4590   }
4591   {
4592     try {
4593       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4594     } catch (std::out_of_range& e) {
4595       {
4596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4597       };
4598     } catch (std::exception& e) {
4599       {
4600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4601       };
4602     } catch (...) {
4603       {
4604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4605       };
4606     }
4607   }
4608   jresult = result;
4609   return jresult;
4610 }
4611
4612
4613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4614   unsigned int jresult ;
4615   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4616   Dali::Vector2 *arg2 = 0 ;
4617   bool result;
4618
4619   arg1 = (Dali::Vector2 *)jarg1;
4620   arg2 = (Dali::Vector2 *)jarg2;
4621   if (!arg2) {
4622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4623     return 0;
4624   }
4625   {
4626     try {
4627       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4628     } catch (std::out_of_range& e) {
4629       {
4630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4631       };
4632     } catch (std::exception& e) {
4633       {
4634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4635       };
4636     } catch (...) {
4637       {
4638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4639       };
4640     }
4641   }
4642   jresult = result;
4643   return jresult;
4644 }
4645
4646
4647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4648   float jresult ;
4649   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4650   unsigned int arg2 ;
4651   float *result = 0 ;
4652
4653   arg1 = (Dali::Vector2 *)jarg1;
4654   arg2 = (unsigned int)jarg2;
4655   {
4656     try {
4657       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4658     } catch (std::out_of_range& e) {
4659       {
4660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4661       };
4662     } catch (std::exception& e) {
4663       {
4664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4665       };
4666     } catch (...) {
4667       {
4668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4669       };
4670     }
4671   }
4672   jresult = *result;
4673   return jresult;
4674 }
4675
4676
4677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4678   float jresult ;
4679   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4680   float result;
4681
4682   arg1 = (Dali::Vector2 *)jarg1;
4683   {
4684     try {
4685       result = (float)((Dali::Vector2 const *)arg1)->Length();
4686     } catch (std::out_of_range& e) {
4687       {
4688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4689       };
4690     } catch (std::exception& e) {
4691       {
4692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4693       };
4694     } catch (...) {
4695       {
4696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4697       };
4698     }
4699   }
4700   jresult = result;
4701   return jresult;
4702 }
4703
4704
4705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4706   float jresult ;
4707   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4708   float result;
4709
4710   arg1 = (Dali::Vector2 *)jarg1;
4711   {
4712     try {
4713       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4714     } catch (std::out_of_range& e) {
4715       {
4716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4717       };
4718     } catch (std::exception& e) {
4719       {
4720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4721       };
4722     } catch (...) {
4723       {
4724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4725       };
4726     }
4727   }
4728   jresult = result;
4729   return jresult;
4730 }
4731
4732
4733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4734   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4735
4736   arg1 = (Dali::Vector2 *)jarg1;
4737   {
4738     try {
4739       (arg1)->Normalize();
4740     } catch (std::out_of_range& e) {
4741       {
4742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4743       };
4744     } catch (std::exception& e) {
4745       {
4746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4747       };
4748     } catch (...) {
4749       {
4750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4751       };
4752     }
4753   }
4754 }
4755
4756
4757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4758   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4759   Dali::Vector2 *arg2 = 0 ;
4760   Dali::Vector2 *arg3 = 0 ;
4761
4762   arg1 = (Dali::Vector2 *)jarg1;
4763   arg2 = (Dali::Vector2 *)jarg2;
4764   if (!arg2) {
4765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4766     return ;
4767   }
4768   arg3 = (Dali::Vector2 *)jarg3;
4769   if (!arg3) {
4770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4771     return ;
4772   }
4773   {
4774     try {
4775       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4776     } catch (std::out_of_range& e) {
4777       {
4778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4779       };
4780     } catch (std::exception& e) {
4781       {
4782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4783       };
4784     } catch (...) {
4785       {
4786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4787       };
4788     }
4789   }
4790 }
4791
4792
4793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4794   void * jresult ;
4795   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4796   float *result = 0 ;
4797
4798   arg1 = (Dali::Vector2 *)jarg1;
4799   {
4800     try {
4801       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4802     } catch (std::out_of_range& e) {
4803       {
4804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4805       };
4806     } catch (std::exception& e) {
4807       {
4808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4809       };
4810     } catch (...) {
4811       {
4812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4813       };
4814     }
4815   }
4816   jresult = (void *)result;
4817   return jresult;
4818 }
4819
4820
4821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4822   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4823   float arg2 ;
4824
4825   arg1 = (Dali::Vector2 *)jarg1;
4826   arg2 = (float)jarg2;
4827   if (arg1) (arg1)->x = arg2;
4828 }
4829
4830
4831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4832   float jresult ;
4833   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4834   float result;
4835
4836   arg1 = (Dali::Vector2 *)jarg1;
4837   result = (float) ((arg1)->x);
4838   jresult = result;
4839   return jresult;
4840 }
4841
4842
4843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4844   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4845   float arg2 ;
4846
4847   arg1 = (Dali::Vector2 *)jarg1;
4848   arg2 = (float)jarg2;
4849   if (arg1) (arg1)->width = arg2;
4850 }
4851
4852
4853 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4854   float jresult ;
4855   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4856   float result;
4857
4858   arg1 = (Dali::Vector2 *)jarg1;
4859   result = (float) ((arg1)->width);
4860   jresult = result;
4861   return jresult;
4862 }
4863
4864
4865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4866   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4867   float arg2 ;
4868
4869   arg1 = (Dali::Vector2 *)jarg1;
4870   arg2 = (float)jarg2;
4871   if (arg1) (arg1)->y = arg2;
4872 }
4873
4874
4875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4876   float jresult ;
4877   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4878   float result;
4879
4880   arg1 = (Dali::Vector2 *)jarg1;
4881   result = (float) ((arg1)->y);
4882   jresult = result;
4883   return jresult;
4884 }
4885
4886
4887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4888   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4889   float arg2 ;
4890
4891   arg1 = (Dali::Vector2 *)jarg1;
4892   arg2 = (float)jarg2;
4893   if (arg1) (arg1)->height = arg2;
4894 }
4895
4896
4897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4898   float jresult ;
4899   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4900   float result;
4901
4902   arg1 = (Dali::Vector2 *)jarg1;
4903   result = (float) ((arg1)->height);
4904   jresult = result;
4905   return jresult;
4906 }
4907
4908
4909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4910   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4911
4912   arg1 = (Dali::Vector2 *)jarg1;
4913   {
4914     try {
4915       delete arg1;
4916     } catch (std::out_of_range& e) {
4917       {
4918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4919       };
4920     } catch (std::exception& e) {
4921       {
4922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4923       };
4924     } catch (...) {
4925       {
4926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4927       };
4928     }
4929   }
4930 }
4931
4932
4933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4934   void * jresult ;
4935   Dali::Vector2 *arg1 = 0 ;
4936   Dali::Vector2 *arg2 = 0 ;
4937   Dali::Vector2 result;
4938
4939   arg1 = (Dali::Vector2 *)jarg1;
4940   if (!arg1) {
4941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4942     return 0;
4943   }
4944   arg2 = (Dali::Vector2 *)jarg2;
4945   if (!arg2) {
4946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4947     return 0;
4948   }
4949   {
4950     try {
4951       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4952     } catch (std::out_of_range& e) {
4953       {
4954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4955       };
4956     } catch (std::exception& e) {
4957       {
4958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4959       };
4960     } catch (...) {
4961       {
4962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4963       };
4964     }
4965   }
4966   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4967   return jresult;
4968 }
4969
4970
4971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4972   void * jresult ;
4973   Dali::Vector2 *arg1 = 0 ;
4974   Dali::Vector2 *arg2 = 0 ;
4975   Dali::Vector2 result;
4976
4977   arg1 = (Dali::Vector2 *)jarg1;
4978   if (!arg1) {
4979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4980     return 0;
4981   }
4982   arg2 = (Dali::Vector2 *)jarg2;
4983   if (!arg2) {
4984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4985     return 0;
4986   }
4987   {
4988     try {
4989       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4990     } catch (std::out_of_range& e) {
4991       {
4992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4993       };
4994     } catch (std::exception& e) {
4995       {
4996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4997       };
4998     } catch (...) {
4999       {
5000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5001       };
5002     }
5003   }
5004   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5005   return jresult;
5006 }
5007
5008
5009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5010   void * jresult ;
5011   Dali::Vector2 *arg1 = 0 ;
5012   float *arg2 = 0 ;
5013   float *arg3 = 0 ;
5014   float temp2 ;
5015   float temp3 ;
5016   Dali::Vector2 result;
5017
5018   arg1 = (Dali::Vector2 *)jarg1;
5019   if (!arg1) {
5020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5021     return 0;
5022   }
5023   temp2 = (float)jarg2;
5024   arg2 = &temp2;
5025   temp3 = (float)jarg3;
5026   arg3 = &temp3;
5027   {
5028     try {
5029       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5030     } catch (std::out_of_range& e) {
5031       {
5032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5033       };
5034     } catch (std::exception& e) {
5035       {
5036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5037       };
5038     } catch (...) {
5039       {
5040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5041       };
5042     }
5043   }
5044   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5045   return jresult;
5046 }
5047
5048
5049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5050   void * jresult ;
5051   Dali::Vector3 *result = 0 ;
5052
5053   {
5054     try {
5055       result = (Dali::Vector3 *)new Dali::Vector3();
5056     } catch (std::out_of_range& e) {
5057       {
5058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5059       };
5060     } catch (std::exception& e) {
5061       {
5062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5063       };
5064     } catch (...) {
5065       {
5066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5067       };
5068     }
5069   }
5070   jresult = (void *)result;
5071   return jresult;
5072 }
5073
5074
5075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5076   void * jresult ;
5077   float arg1 ;
5078   float arg2 ;
5079   float arg3 ;
5080   Dali::Vector3 *result = 0 ;
5081
5082   arg1 = (float)jarg1;
5083   arg2 = (float)jarg2;
5084   arg3 = (float)jarg3;
5085   {
5086     try {
5087       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5088     } catch (std::out_of_range& e) {
5089       {
5090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5091       };
5092     } catch (std::exception& e) {
5093       {
5094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5095       };
5096     } catch (...) {
5097       {
5098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5099       };
5100     }
5101   }
5102   jresult = (void *)result;
5103   return jresult;
5104 }
5105
5106
5107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5108   void * jresult ;
5109   float *arg1 = (float *) 0 ;
5110   Dali::Vector3 *result = 0 ;
5111
5112   arg1 = jarg1;
5113   {
5114     try {
5115       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5116     } catch (std::out_of_range& e) {
5117       {
5118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5119       };
5120     } catch (std::exception& e) {
5121       {
5122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5123       };
5124     } catch (...) {
5125       {
5126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5127       };
5128     }
5129   }
5130   jresult = (void *)result;
5131
5132
5133   return jresult;
5134 }
5135
5136
5137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5138   void * jresult ;
5139   Dali::Vector2 *arg1 = 0 ;
5140   Dali::Vector3 *result = 0 ;
5141
5142   arg1 = (Dali::Vector2 *)jarg1;
5143   if (!arg1) {
5144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5145     return 0;
5146   }
5147   {
5148     try {
5149       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5150     } catch (std::out_of_range& e) {
5151       {
5152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5153       };
5154     } catch (std::exception& e) {
5155       {
5156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5157       };
5158     } catch (...) {
5159       {
5160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5161       };
5162     }
5163   }
5164   jresult = (void *)result;
5165   return jresult;
5166 }
5167
5168
5169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5170   void * jresult ;
5171   Dali::Vector4 *arg1 = 0 ;
5172   Dali::Vector3 *result = 0 ;
5173
5174   arg1 = (Dali::Vector4 *)jarg1;
5175   if (!arg1) {
5176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5177     return 0;
5178   }
5179   {
5180     try {
5181       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5182     } catch (std::out_of_range& e) {
5183       {
5184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5185       };
5186     } catch (std::exception& e) {
5187       {
5188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5189       };
5190     } catch (...) {
5191       {
5192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5193       };
5194     }
5195   }
5196   jresult = (void *)result;
5197   return jresult;
5198 }
5199
5200
5201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5202   void * jresult ;
5203   Dali::Vector3 *result = 0 ;
5204
5205   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5206   jresult = (void *)result;
5207   return jresult;
5208 }
5209
5210
5211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5212   void * jresult ;
5213   Dali::Vector3 *result = 0 ;
5214
5215   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5216   jresult = (void *)result;
5217   return jresult;
5218 }
5219
5220
5221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5222   void * jresult ;
5223   Dali::Vector3 *result = 0 ;
5224
5225   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5226   jresult = (void *)result;
5227   return jresult;
5228 }
5229
5230
5231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5232   void * jresult ;
5233   Dali::Vector3 *result = 0 ;
5234
5235   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5236   jresult = (void *)result;
5237   return jresult;
5238 }
5239
5240
5241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5242   void * jresult ;
5243   Dali::Vector3 *result = 0 ;
5244
5245   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5246   jresult = (void *)result;
5247   return jresult;
5248 }
5249
5250
5251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5252   void * jresult ;
5253   Dali::Vector3 *result = 0 ;
5254
5255   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5256   jresult = (void *)result;
5257   return jresult;
5258 }
5259
5260
5261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5262   void * jresult ;
5263   Dali::Vector3 *result = 0 ;
5264
5265   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5266   jresult = (void *)result;
5267   return jresult;
5268 }
5269
5270
5271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5272   void * jresult ;
5273   Dali::Vector3 *result = 0 ;
5274
5275   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5276   jresult = (void *)result;
5277   return jresult;
5278 }
5279
5280
5281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5282   void * jresult ;
5283   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5284   float *arg2 = (float *) 0 ;
5285   Dali::Vector3 *result = 0 ;
5286
5287   arg1 = (Dali::Vector3 *)jarg1;
5288   arg2 = jarg2;
5289   {
5290     try {
5291       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5292     } catch (std::out_of_range& e) {
5293       {
5294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5295       };
5296     } catch (std::exception& e) {
5297       {
5298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5299       };
5300     } catch (...) {
5301       {
5302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5303       };
5304     }
5305   }
5306   jresult = (void *)result;
5307
5308
5309   return jresult;
5310 }
5311
5312
5313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5314   void * jresult ;
5315   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5316   Dali::Vector2 *arg2 = 0 ;
5317   Dali::Vector3 *result = 0 ;
5318
5319   arg1 = (Dali::Vector3 *)jarg1;
5320   arg2 = (Dali::Vector2 *)jarg2;
5321   if (!arg2) {
5322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5323     return 0;
5324   }
5325   {
5326     try {
5327       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5328     } catch (std::out_of_range& e) {
5329       {
5330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5331       };
5332     } catch (std::exception& e) {
5333       {
5334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5335       };
5336     } catch (...) {
5337       {
5338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5339       };
5340     }
5341   }
5342   jresult = (void *)result;
5343   return jresult;
5344 }
5345
5346
5347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5348   void * jresult ;
5349   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5350   Dali::Vector4 *arg2 = 0 ;
5351   Dali::Vector3 *result = 0 ;
5352
5353   arg1 = (Dali::Vector3 *)jarg1;
5354   arg2 = (Dali::Vector4 *)jarg2;
5355   if (!arg2) {
5356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5357     return 0;
5358   }
5359   {
5360     try {
5361       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5362     } catch (std::out_of_range& e) {
5363       {
5364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5365       };
5366     } catch (std::exception& e) {
5367       {
5368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5369       };
5370     } catch (...) {
5371       {
5372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5373       };
5374     }
5375   }
5376   jresult = (void *)result;
5377   return jresult;
5378 }
5379
5380
5381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5382   void * jresult ;
5383   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5384   Dali::Vector3 *arg2 = 0 ;
5385   Dali::Vector3 result;
5386
5387   arg1 = (Dali::Vector3 *)jarg1;
5388   arg2 = (Dali::Vector3 *)jarg2;
5389   if (!arg2) {
5390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5391     return 0;
5392   }
5393   {
5394     try {
5395       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5396     } catch (std::out_of_range& e) {
5397       {
5398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5399       };
5400     } catch (std::exception& e) {
5401       {
5402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5403       };
5404     } catch (...) {
5405       {
5406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5407       };
5408     }
5409   }
5410   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5411   return jresult;
5412 }
5413
5414
5415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5416   void * jresult ;
5417   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5418   Dali::Vector3 *arg2 = 0 ;
5419   Dali::Vector3 *result = 0 ;
5420
5421   arg1 = (Dali::Vector3 *)jarg1;
5422   arg2 = (Dali::Vector3 *)jarg2;
5423   if (!arg2) {
5424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5425     return 0;
5426   }
5427   {
5428     try {
5429       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5430     } catch (std::out_of_range& e) {
5431       {
5432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5433       };
5434     } catch (std::exception& e) {
5435       {
5436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5437       };
5438     } catch (...) {
5439       {
5440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5441       };
5442     }
5443   }
5444   jresult = (void *)result;
5445   return jresult;
5446 }
5447
5448
5449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5450   void * jresult ;
5451   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5452   Dali::Vector3 *arg2 = 0 ;
5453   Dali::Vector3 result;
5454
5455   arg1 = (Dali::Vector3 *)jarg1;
5456   arg2 = (Dali::Vector3 *)jarg2;
5457   if (!arg2) {
5458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5459     return 0;
5460   }
5461   {
5462     try {
5463       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5464     } catch (std::out_of_range& e) {
5465       {
5466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5467       };
5468     } catch (std::exception& e) {
5469       {
5470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5471       };
5472     } catch (...) {
5473       {
5474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5475       };
5476     }
5477   }
5478   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5479   return jresult;
5480 }
5481
5482
5483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5484   void * jresult ;
5485   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5486   Dali::Vector3 *arg2 = 0 ;
5487   Dali::Vector3 *result = 0 ;
5488
5489   arg1 = (Dali::Vector3 *)jarg1;
5490   arg2 = (Dali::Vector3 *)jarg2;
5491   if (!arg2) {
5492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5493     return 0;
5494   }
5495   {
5496     try {
5497       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5498     } catch (std::out_of_range& e) {
5499       {
5500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5501       };
5502     } catch (std::exception& e) {
5503       {
5504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5505       };
5506     } catch (...) {
5507       {
5508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5509       };
5510     }
5511   }
5512   jresult = (void *)result;
5513   return jresult;
5514 }
5515
5516
5517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5518   void * jresult ;
5519   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5520   Dali::Vector3 *arg2 = 0 ;
5521   Dali::Vector3 result;
5522
5523   arg1 = (Dali::Vector3 *)jarg1;
5524   arg2 = (Dali::Vector3 *)jarg2;
5525   if (!arg2) {
5526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5527     return 0;
5528   }
5529   {
5530     try {
5531       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5532     } catch (std::out_of_range& e) {
5533       {
5534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5535       };
5536     } catch (std::exception& e) {
5537       {
5538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5539       };
5540     } catch (...) {
5541       {
5542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5543       };
5544     }
5545   }
5546   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5547   return jresult;
5548 }
5549
5550
5551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5552   void * jresult ;
5553   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5554   float arg2 ;
5555   Dali::Vector3 result;
5556
5557   arg1 = (Dali::Vector3 *)jarg1;
5558   arg2 = (float)jarg2;
5559   {
5560     try {
5561       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
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 (...) {
5571       {
5572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5573       };
5574     }
5575   }
5576   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5577   return jresult;
5578 }
5579
5580
5581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5582   void * jresult ;
5583   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5584   Dali::Vector3 *arg2 = 0 ;
5585   Dali::Vector3 *result = 0 ;
5586
5587   arg1 = (Dali::Vector3 *)jarg1;
5588   arg2 = (Dali::Vector3 *)jarg2;
5589   if (!arg2) {
5590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5591     return 0;
5592   }
5593   {
5594     try {
5595       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5596     } catch (std::out_of_range& e) {
5597       {
5598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5599       };
5600     } catch (std::exception& e) {
5601       {
5602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (...) {
5605       {
5606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5607       };
5608     }
5609   }
5610   jresult = (void *)result;
5611   return jresult;
5612 }
5613
5614
5615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5616   void * jresult ;
5617   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5618   float arg2 ;
5619   Dali::Vector3 *result = 0 ;
5620
5621   arg1 = (Dali::Vector3 *)jarg1;
5622   arg2 = (float)jarg2;
5623   {
5624     try {
5625       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5626     } catch (std::out_of_range& e) {
5627       {
5628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5629       };
5630     } catch (std::exception& e) {
5631       {
5632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5633       };
5634     } catch (...) {
5635       {
5636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5637       };
5638     }
5639   }
5640   jresult = (void *)result;
5641   return jresult;
5642 }
5643
5644
5645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5646   void * jresult ;
5647   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5648   Dali::Quaternion *arg2 = 0 ;
5649   Dali::Vector3 *result = 0 ;
5650
5651   arg1 = (Dali::Vector3 *)jarg1;
5652   arg2 = (Dali::Quaternion *)jarg2;
5653   if (!arg2) {
5654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5655     return 0;
5656   }
5657   {
5658     try {
5659       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5660     } catch (std::out_of_range& e) {
5661       {
5662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5663       };
5664     } catch (std::exception& e) {
5665       {
5666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5667       };
5668     } catch (...) {
5669       {
5670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5671       };
5672     }
5673   }
5674   jresult = (void *)result;
5675   return jresult;
5676 }
5677
5678
5679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5680   void * jresult ;
5681   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5682   Dali::Vector3 *arg2 = 0 ;
5683   Dali::Vector3 result;
5684
5685   arg1 = (Dali::Vector3 *)jarg1;
5686   arg2 = (Dali::Vector3 *)jarg2;
5687   if (!arg2) {
5688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5689     return 0;
5690   }
5691   {
5692     try {
5693       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5694     } catch (std::out_of_range& e) {
5695       {
5696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5697       };
5698     } catch (std::exception& e) {
5699       {
5700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5701       };
5702     } catch (...) {
5703       {
5704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5705       };
5706     }
5707   }
5708   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5709   return jresult;
5710 }
5711
5712
5713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5714   void * jresult ;
5715   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5716   float arg2 ;
5717   Dali::Vector3 result;
5718
5719   arg1 = (Dali::Vector3 *)jarg1;
5720   arg2 = (float)jarg2;
5721   {
5722     try {
5723       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5724     } catch (std::out_of_range& e) {
5725       {
5726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5727       };
5728     } catch (std::exception& e) {
5729       {
5730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5731       };
5732     } catch (...) {
5733       {
5734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5735       };
5736     }
5737   }
5738   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5739   return jresult;
5740 }
5741
5742
5743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5744   void * jresult ;
5745   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5746   Dali::Vector3 *arg2 = 0 ;
5747   Dali::Vector3 *result = 0 ;
5748
5749   arg1 = (Dali::Vector3 *)jarg1;
5750   arg2 = (Dali::Vector3 *)jarg2;
5751   if (!arg2) {
5752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5753     return 0;
5754   }
5755   {
5756     try {
5757       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5758     } catch (std::out_of_range& e) {
5759       {
5760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5761       };
5762     } catch (std::exception& e) {
5763       {
5764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5765       };
5766     } catch (...) {
5767       {
5768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5769       };
5770     }
5771   }
5772   jresult = (void *)result;
5773   return jresult;
5774 }
5775
5776
5777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5778   void * jresult ;
5779   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5780   float arg2 ;
5781   Dali::Vector3 *result = 0 ;
5782
5783   arg1 = (Dali::Vector3 *)jarg1;
5784   arg2 = (float)jarg2;
5785   {
5786     try {
5787       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5788     } catch (std::out_of_range& e) {
5789       {
5790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5791       };
5792     } catch (std::exception& e) {
5793       {
5794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5795       };
5796     } catch (...) {
5797       {
5798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5799       };
5800     }
5801   }
5802   jresult = (void *)result;
5803   return jresult;
5804 }
5805
5806
5807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5808   void * jresult ;
5809   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5810   Dali::Vector3 result;
5811
5812   arg1 = (Dali::Vector3 *)jarg1;
5813   {
5814     try {
5815       result = ((Dali::Vector3 const *)arg1)->operator -();
5816     } catch (std::out_of_range& e) {
5817       {
5818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5819       };
5820     } catch (std::exception& e) {
5821       {
5822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5823       };
5824     } catch (...) {
5825       {
5826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5827       };
5828     }
5829   }
5830   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5831   return jresult;
5832 }
5833
5834
5835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5836   unsigned int jresult ;
5837   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5838   Dali::Vector3 *arg2 = 0 ;
5839   bool result;
5840
5841   arg1 = (Dali::Vector3 *)jarg1;
5842   arg2 = (Dali::Vector3 *)jarg2;
5843   if (!arg2) {
5844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5845     return 0;
5846   }
5847   {
5848     try {
5849       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5850     } catch (std::out_of_range& e) {
5851       {
5852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5853       };
5854     } catch (std::exception& e) {
5855       {
5856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5857       };
5858     } catch (...) {
5859       {
5860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5861       };
5862     }
5863   }
5864   jresult = result;
5865   return jresult;
5866 }
5867
5868
5869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5870   unsigned int jresult ;
5871   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5872   Dali::Vector3 *arg2 = 0 ;
5873   bool result;
5874
5875   arg1 = (Dali::Vector3 *)jarg1;
5876   arg2 = (Dali::Vector3 *)jarg2;
5877   if (!arg2) {
5878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5879     return 0;
5880   }
5881   {
5882     try {
5883       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5884     } catch (std::out_of_range& e) {
5885       {
5886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5887       };
5888     } catch (std::exception& e) {
5889       {
5890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5891       };
5892     } catch (...) {
5893       {
5894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5895       };
5896     }
5897   }
5898   jresult = result;
5899   return jresult;
5900 }
5901
5902
5903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5904   float jresult ;
5905   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5906   unsigned int arg2 ;
5907   float *result = 0 ;
5908
5909   arg1 = (Dali::Vector3 *)jarg1;
5910   arg2 = (unsigned int)jarg2;
5911   {
5912     try {
5913       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5914     } catch (std::out_of_range& e) {
5915       {
5916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5917       };
5918     } catch (std::exception& e) {
5919       {
5920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5921       };
5922     } catch (...) {
5923       {
5924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5925       };
5926     }
5927   }
5928   jresult = *result;
5929   return jresult;
5930 }
5931
5932
5933 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5934   float jresult ;
5935   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5936   Dali::Vector3 *arg2 = 0 ;
5937   float result;
5938
5939   arg1 = (Dali::Vector3 *)jarg1;
5940   arg2 = (Dali::Vector3 *)jarg2;
5941   if (!arg2) {
5942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5943     return 0;
5944   }
5945   {
5946     try {
5947       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5948     } catch (std::out_of_range& e) {
5949       {
5950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5951       };
5952     } catch (std::exception& e) {
5953       {
5954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5955       };
5956     } catch (...) {
5957       {
5958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5959       };
5960     }
5961   }
5962   jresult = result;
5963   return jresult;
5964 }
5965
5966
5967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5968   void * jresult ;
5969   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5970   Dali::Vector3 *arg2 = 0 ;
5971   Dali::Vector3 result;
5972
5973   arg1 = (Dali::Vector3 *)jarg1;
5974   arg2 = (Dali::Vector3 *)jarg2;
5975   if (!arg2) {
5976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5977     return 0;
5978   }
5979   {
5980     try {
5981       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
5982     } catch (std::out_of_range& e) {
5983       {
5984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5985       };
5986     } catch (std::exception& e) {
5987       {
5988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5989       };
5990     } catch (...) {
5991       {
5992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5993       };
5994     }
5995   }
5996   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5997   return jresult;
5998 }
5999
6000
6001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6002   float jresult ;
6003   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6004   float result;
6005
6006   arg1 = (Dali::Vector3 *)jarg1;
6007   {
6008     try {
6009       result = (float)((Dali::Vector3 const *)arg1)->Length();
6010     } catch (std::out_of_range& e) {
6011       {
6012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6013       };
6014     } catch (std::exception& e) {
6015       {
6016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6017       };
6018     } catch (...) {
6019       {
6020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6021       };
6022     }
6023   }
6024   jresult = result;
6025   return jresult;
6026 }
6027
6028
6029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6030   float jresult ;
6031   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6032   float result;
6033
6034   arg1 = (Dali::Vector3 *)jarg1;
6035   {
6036     try {
6037       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6038     } catch (std::out_of_range& e) {
6039       {
6040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6041       };
6042     } catch (std::exception& e) {
6043       {
6044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6045       };
6046     } catch (...) {
6047       {
6048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6049       };
6050     }
6051   }
6052   jresult = result;
6053   return jresult;
6054 }
6055
6056
6057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6058   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6059
6060   arg1 = (Dali::Vector3 *)jarg1;
6061   {
6062     try {
6063       (arg1)->Normalize();
6064     } catch (std::out_of_range& e) {
6065       {
6066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6067       };
6068     } catch (std::exception& e) {
6069       {
6070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6071       };
6072     } catch (...) {
6073       {
6074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6075       };
6076     }
6077   }
6078 }
6079
6080
6081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6082   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6083   Dali::Vector3 *arg2 = 0 ;
6084   Dali::Vector3 *arg3 = 0 ;
6085
6086   arg1 = (Dali::Vector3 *)jarg1;
6087   arg2 = (Dali::Vector3 *)jarg2;
6088   if (!arg2) {
6089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6090     return ;
6091   }
6092   arg3 = (Dali::Vector3 *)jarg3;
6093   if (!arg3) {
6094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6095     return ;
6096   }
6097   {
6098     try {
6099       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6100     } catch (std::out_of_range& e) {
6101       {
6102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6103       };
6104     } catch (std::exception& e) {
6105       {
6106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6107       };
6108     } catch (...) {
6109       {
6110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6111       };
6112     }
6113   }
6114 }
6115
6116
6117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6118   void * jresult ;
6119   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6120   float *result = 0 ;
6121
6122   arg1 = (Dali::Vector3 *)jarg1;
6123   {
6124     try {
6125       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6126     } catch (std::out_of_range& e) {
6127       {
6128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6129       };
6130     } catch (std::exception& e) {
6131       {
6132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6133       };
6134     } catch (...) {
6135       {
6136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6137       };
6138     }
6139   }
6140   jresult = (void *)result;
6141   return jresult;
6142 }
6143
6144
6145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6146   void * jresult ;
6147   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6148   Dali::Vector2 *result = 0 ;
6149
6150   arg1 = (Dali::Vector3 *)jarg1;
6151   {
6152     try {
6153       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6154     } catch (std::out_of_range& e) {
6155       {
6156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6157       };
6158     } catch (std::exception& e) {
6159       {
6160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6161       };
6162     } catch (...) {
6163       {
6164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6165       };
6166     }
6167   }
6168   jresult = (void *)result;
6169   return jresult;
6170 }
6171
6172
6173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6174   void * jresult ;
6175   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6176   Dali::Vector2 *result = 0 ;
6177
6178   arg1 = (Dali::Vector3 *)jarg1;
6179   {
6180     try {
6181       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6182     } catch (std::out_of_range& e) {
6183       {
6184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6185       };
6186     } catch (std::exception& e) {
6187       {
6188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6189       };
6190     } catch (...) {
6191       {
6192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6193       };
6194     }
6195   }
6196   jresult = (void *)result;
6197   return jresult;
6198 }
6199
6200
6201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6202   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6203   float arg2 ;
6204
6205   arg1 = (Dali::Vector3 *)jarg1;
6206   arg2 = (float)jarg2;
6207   if (arg1) (arg1)->x = arg2;
6208 }
6209
6210
6211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6212   float jresult ;
6213   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6214   float result;
6215
6216   arg1 = (Dali::Vector3 *)jarg1;
6217   result = (float) ((arg1)->x);
6218   jresult = result;
6219   return jresult;
6220 }
6221
6222
6223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6224   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6225   float arg2 ;
6226
6227   arg1 = (Dali::Vector3 *)jarg1;
6228   arg2 = (float)jarg2;
6229   if (arg1) (arg1)->width = arg2;
6230 }
6231
6232
6233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6234   float jresult ;
6235   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6236   float result;
6237
6238   arg1 = (Dali::Vector3 *)jarg1;
6239   result = (float) ((arg1)->width);
6240   jresult = result;
6241   return jresult;
6242 }
6243
6244
6245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6246   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6247   float arg2 ;
6248
6249   arg1 = (Dali::Vector3 *)jarg1;
6250   arg2 = (float)jarg2;
6251   if (arg1) (arg1)->r = arg2;
6252 }
6253
6254
6255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6256   float jresult ;
6257   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6258   float result;
6259
6260   arg1 = (Dali::Vector3 *)jarg1;
6261   result = (float) ((arg1)->r);
6262   jresult = result;
6263   return jresult;
6264 }
6265
6266
6267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6268   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6269   float arg2 ;
6270
6271   arg1 = (Dali::Vector3 *)jarg1;
6272   arg2 = (float)jarg2;
6273   if (arg1) (arg1)->y = arg2;
6274 }
6275
6276
6277 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6278   float jresult ;
6279   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6280   float result;
6281
6282   arg1 = (Dali::Vector3 *)jarg1;
6283   result = (float) ((arg1)->y);
6284   jresult = result;
6285   return jresult;
6286 }
6287
6288
6289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6290   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6291   float arg2 ;
6292
6293   arg1 = (Dali::Vector3 *)jarg1;
6294   arg2 = (float)jarg2;
6295   if (arg1) (arg1)->height = arg2;
6296 }
6297
6298
6299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6300   float jresult ;
6301   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6302   float result;
6303
6304   arg1 = (Dali::Vector3 *)jarg1;
6305   result = (float) ((arg1)->height);
6306   jresult = result;
6307   return jresult;
6308 }
6309
6310
6311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6312   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6313   float arg2 ;
6314
6315   arg1 = (Dali::Vector3 *)jarg1;
6316   arg2 = (float)jarg2;
6317   if (arg1) (arg1)->g = arg2;
6318 }
6319
6320
6321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6322   float jresult ;
6323   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6324   float result;
6325
6326   arg1 = (Dali::Vector3 *)jarg1;
6327   result = (float) ((arg1)->g);
6328   jresult = result;
6329   return jresult;
6330 }
6331
6332
6333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6334   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6335   float arg2 ;
6336
6337   arg1 = (Dali::Vector3 *)jarg1;
6338   arg2 = (float)jarg2;
6339   if (arg1) (arg1)->z = arg2;
6340 }
6341
6342
6343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6344   float jresult ;
6345   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6346   float result;
6347
6348   arg1 = (Dali::Vector3 *)jarg1;
6349   result = (float) ((arg1)->z);
6350   jresult = result;
6351   return jresult;
6352 }
6353
6354
6355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6356   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6357   float arg2 ;
6358
6359   arg1 = (Dali::Vector3 *)jarg1;
6360   arg2 = (float)jarg2;
6361   if (arg1) (arg1)->depth = arg2;
6362 }
6363
6364
6365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6366   float jresult ;
6367   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6368   float result;
6369
6370   arg1 = (Dali::Vector3 *)jarg1;
6371   result = (float) ((arg1)->depth);
6372   jresult = result;
6373   return jresult;
6374 }
6375
6376
6377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6378   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6379   float arg2 ;
6380
6381   arg1 = (Dali::Vector3 *)jarg1;
6382   arg2 = (float)jarg2;
6383   if (arg1) (arg1)->b = arg2;
6384 }
6385
6386
6387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6388   float jresult ;
6389   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6390   float result;
6391
6392   arg1 = (Dali::Vector3 *)jarg1;
6393   result = (float) ((arg1)->b);
6394   jresult = result;
6395   return jresult;
6396 }
6397
6398
6399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6400   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6401
6402   arg1 = (Dali::Vector3 *)jarg1;
6403   {
6404     try {
6405       delete arg1;
6406     } catch (std::out_of_range& e) {
6407       {
6408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6409       };
6410     } catch (std::exception& e) {
6411       {
6412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6413       };
6414     } catch (...) {
6415       {
6416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6417       };
6418     }
6419   }
6420 }
6421
6422
6423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6424   void * jresult ;
6425   Dali::Vector3 *arg1 = 0 ;
6426   Dali::Vector3 *arg2 = 0 ;
6427   Dali::Vector3 result;
6428
6429   arg1 = (Dali::Vector3 *)jarg1;
6430   if (!arg1) {
6431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6432     return 0;
6433   }
6434   arg2 = (Dali::Vector3 *)jarg2;
6435   if (!arg2) {
6436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6437     return 0;
6438   }
6439   {
6440     try {
6441       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6442     } catch (std::out_of_range& e) {
6443       {
6444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6445       };
6446     } catch (std::exception& e) {
6447       {
6448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6449       };
6450     } catch (...) {
6451       {
6452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6453       };
6454     }
6455   }
6456   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6457   return jresult;
6458 }
6459
6460
6461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6462   void * jresult ;
6463   Dali::Vector3 *arg1 = 0 ;
6464   Dali::Vector3 *arg2 = 0 ;
6465   Dali::Vector3 result;
6466
6467   arg1 = (Dali::Vector3 *)jarg1;
6468   if (!arg1) {
6469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6470     return 0;
6471   }
6472   arg2 = (Dali::Vector3 *)jarg2;
6473   if (!arg2) {
6474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6475     return 0;
6476   }
6477   {
6478     try {
6479       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6480     } catch (std::out_of_range& e) {
6481       {
6482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6483       };
6484     } catch (std::exception& e) {
6485       {
6486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6487       };
6488     } catch (...) {
6489       {
6490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6491       };
6492     }
6493   }
6494   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6495   return jresult;
6496 }
6497
6498
6499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6500   void * jresult ;
6501   Dali::Vector3 *arg1 = 0 ;
6502   float *arg2 = 0 ;
6503   float *arg3 = 0 ;
6504   float temp2 ;
6505   float temp3 ;
6506   Dali::Vector3 result;
6507
6508   arg1 = (Dali::Vector3 *)jarg1;
6509   if (!arg1) {
6510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6511     return 0;
6512   }
6513   temp2 = (float)jarg2;
6514   arg2 = &temp2;
6515   temp3 = (float)jarg3;
6516   arg3 = &temp3;
6517   {
6518     try {
6519       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6520     } catch (std::out_of_range& e) {
6521       {
6522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6523       };
6524     } catch (std::exception& e) {
6525       {
6526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6527       };
6528     } catch (...) {
6529       {
6530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6531       };
6532     }
6533   }
6534   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6535   return jresult;
6536 }
6537
6538
6539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6540   void * jresult ;
6541   Dali::Vector4 *result = 0 ;
6542
6543   {
6544     try {
6545       result = (Dali::Vector4 *)new Dali::Vector4();
6546     } catch (std::out_of_range& e) {
6547       {
6548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6549       };
6550     } catch (std::exception& e) {
6551       {
6552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6553       };
6554     } catch (...) {
6555       {
6556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6557       };
6558     }
6559   }
6560   jresult = (void *)result;
6561   return jresult;
6562 }
6563
6564
6565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6566   void * jresult ;
6567   float arg1 ;
6568   float arg2 ;
6569   float arg3 ;
6570   float arg4 ;
6571   Dali::Vector4 *result = 0 ;
6572
6573   arg1 = (float)jarg1;
6574   arg2 = (float)jarg2;
6575   arg3 = (float)jarg3;
6576   arg4 = (float)jarg4;
6577   {
6578     try {
6579       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6580     } catch (std::out_of_range& e) {
6581       {
6582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6583       };
6584     } catch (std::exception& e) {
6585       {
6586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6587       };
6588     } catch (...) {
6589       {
6590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6591       };
6592     }
6593   }
6594   jresult = (void *)result;
6595   return jresult;
6596 }
6597
6598
6599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6600   void * jresult ;
6601   float *arg1 = (float *) 0 ;
6602   Dali::Vector4 *result = 0 ;
6603
6604   arg1 = jarg1;
6605   {
6606     try {
6607       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6608     } catch (std::out_of_range& e) {
6609       {
6610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6611       };
6612     } catch (std::exception& e) {
6613       {
6614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6615       };
6616     } catch (...) {
6617       {
6618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6619       };
6620     }
6621   }
6622   jresult = (void *)result;
6623
6624
6625   return jresult;
6626 }
6627
6628
6629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6630   void * jresult ;
6631   Dali::Vector2 *arg1 = 0 ;
6632   Dali::Vector4 *result = 0 ;
6633
6634   arg1 = (Dali::Vector2 *)jarg1;
6635   if (!arg1) {
6636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6637     return 0;
6638   }
6639   {
6640     try {
6641       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6642     } catch (std::out_of_range& e) {
6643       {
6644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6645       };
6646     } catch (std::exception& e) {
6647       {
6648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6649       };
6650     } catch (...) {
6651       {
6652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6653       };
6654     }
6655   }
6656   jresult = (void *)result;
6657   return jresult;
6658 }
6659
6660
6661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6662   void * jresult ;
6663   Dali::Vector3 *arg1 = 0 ;
6664   Dali::Vector4 *result = 0 ;
6665
6666   arg1 = (Dali::Vector3 *)jarg1;
6667   if (!arg1) {
6668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6669     return 0;
6670   }
6671   {
6672     try {
6673       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6674     } catch (std::out_of_range& e) {
6675       {
6676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6677       };
6678     } catch (std::exception& e) {
6679       {
6680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6681       };
6682     } catch (...) {
6683       {
6684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6685       };
6686     }
6687   }
6688   jresult = (void *)result;
6689   return jresult;
6690 }
6691
6692
6693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6694   void * jresult ;
6695   Dali::Vector4 *result = 0 ;
6696
6697   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6698   jresult = (void *)result;
6699   return jresult;
6700 }
6701
6702
6703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6704   void * jresult ;
6705   Dali::Vector4 *result = 0 ;
6706
6707   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6708   jresult = (void *)result;
6709   return jresult;
6710 }
6711
6712
6713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6714   void * jresult ;
6715   Dali::Vector4 *result = 0 ;
6716
6717   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6718   jresult = (void *)result;
6719   return jresult;
6720 }
6721
6722
6723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6724   void * jresult ;
6725   Dali::Vector4 *result = 0 ;
6726
6727   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6728   jresult = (void *)result;
6729   return jresult;
6730 }
6731
6732
6733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6734   void * jresult ;
6735   Dali::Vector4 *result = 0 ;
6736
6737   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6738   jresult = (void *)result;
6739   return jresult;
6740 }
6741
6742
6743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6744   void * jresult ;
6745   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6746   float *arg2 = (float *) 0 ;
6747   Dali::Vector4 *result = 0 ;
6748
6749   arg1 = (Dali::Vector4 *)jarg1;
6750   arg2 = jarg2;
6751   {
6752     try {
6753       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6754     } catch (std::out_of_range& e) {
6755       {
6756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6757       };
6758     } catch (std::exception& e) {
6759       {
6760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6761       };
6762     } catch (...) {
6763       {
6764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6765       };
6766     }
6767   }
6768   jresult = (void *)result;
6769
6770
6771   return jresult;
6772 }
6773
6774
6775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6776   void * jresult ;
6777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6778   Dali::Vector2 *arg2 = 0 ;
6779   Dali::Vector4 *result = 0 ;
6780
6781   arg1 = (Dali::Vector4 *)jarg1;
6782   arg2 = (Dali::Vector2 *)jarg2;
6783   if (!arg2) {
6784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6785     return 0;
6786   }
6787   {
6788     try {
6789       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6790     } catch (std::out_of_range& e) {
6791       {
6792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6793       };
6794     } catch (std::exception& e) {
6795       {
6796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6797       };
6798     } catch (...) {
6799       {
6800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6801       };
6802     }
6803   }
6804   jresult = (void *)result;
6805   return jresult;
6806 }
6807
6808
6809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6810   void * jresult ;
6811   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6812   Dali::Vector3 *arg2 = 0 ;
6813   Dali::Vector4 *result = 0 ;
6814
6815   arg1 = (Dali::Vector4 *)jarg1;
6816   arg2 = (Dali::Vector3 *)jarg2;
6817   if (!arg2) {
6818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6819     return 0;
6820   }
6821   {
6822     try {
6823       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6824     } catch (std::out_of_range& e) {
6825       {
6826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6827       };
6828     } catch (std::exception& e) {
6829       {
6830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6831       };
6832     } catch (...) {
6833       {
6834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6835       };
6836     }
6837   }
6838   jresult = (void *)result;
6839   return jresult;
6840 }
6841
6842
6843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6844   void * jresult ;
6845   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6846   Dali::Vector4 *arg2 = 0 ;
6847   Dali::Vector4 result;
6848
6849   arg1 = (Dali::Vector4 *)jarg1;
6850   arg2 = (Dali::Vector4 *)jarg2;
6851   if (!arg2) {
6852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6853     return 0;
6854   }
6855   {
6856     try {
6857       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6858     } catch (std::out_of_range& e) {
6859       {
6860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6861       };
6862     } catch (std::exception& e) {
6863       {
6864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6865       };
6866     } catch (...) {
6867       {
6868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6869       };
6870     }
6871   }
6872   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6873   return jresult;
6874 }
6875
6876
6877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6878   void * jresult ;
6879   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6880   Dali::Vector4 *arg2 = 0 ;
6881   Dali::Vector4 *result = 0 ;
6882
6883   arg1 = (Dali::Vector4 *)jarg1;
6884   arg2 = (Dali::Vector4 *)jarg2;
6885   if (!arg2) {
6886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6887     return 0;
6888   }
6889   {
6890     try {
6891       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6892     } catch (std::out_of_range& e) {
6893       {
6894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6895       };
6896     } catch (std::exception& e) {
6897       {
6898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6899       };
6900     } catch (...) {
6901       {
6902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6903       };
6904     }
6905   }
6906   jresult = (void *)result;
6907   return jresult;
6908 }
6909
6910
6911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6912   void * jresult ;
6913   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6914   Dali::Vector4 *arg2 = 0 ;
6915   Dali::Vector4 result;
6916
6917   arg1 = (Dali::Vector4 *)jarg1;
6918   arg2 = (Dali::Vector4 *)jarg2;
6919   if (!arg2) {
6920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6921     return 0;
6922   }
6923   {
6924     try {
6925       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6926     } catch (std::out_of_range& e) {
6927       {
6928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6929       };
6930     } catch (std::exception& e) {
6931       {
6932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6933       };
6934     } catch (...) {
6935       {
6936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6937       };
6938     }
6939   }
6940   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6941   return jresult;
6942 }
6943
6944
6945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6946   void * jresult ;
6947   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6948   Dali::Vector4 *arg2 = 0 ;
6949   Dali::Vector4 *result = 0 ;
6950
6951   arg1 = (Dali::Vector4 *)jarg1;
6952   arg2 = (Dali::Vector4 *)jarg2;
6953   if (!arg2) {
6954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6955     return 0;
6956   }
6957   {
6958     try {
6959       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6960     } catch (std::out_of_range& e) {
6961       {
6962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6963       };
6964     } catch (std::exception& e) {
6965       {
6966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6967       };
6968     } catch (...) {
6969       {
6970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6971       };
6972     }
6973   }
6974   jresult = (void *)result;
6975   return jresult;
6976 }
6977
6978
6979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6980   void * jresult ;
6981   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6982   Dali::Vector4 *arg2 = 0 ;
6983   Dali::Vector4 result;
6984
6985   arg1 = (Dali::Vector4 *)jarg1;
6986   arg2 = (Dali::Vector4 *)jarg2;
6987   if (!arg2) {
6988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6989     return 0;
6990   }
6991   {
6992     try {
6993       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
6994     } catch (std::out_of_range& e) {
6995       {
6996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6997       };
6998     } catch (std::exception& e) {
6999       {
7000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7001       };
7002     } catch (...) {
7003       {
7004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7005       };
7006     }
7007   }
7008   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7009   return jresult;
7010 }
7011
7012
7013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7014   void * jresult ;
7015   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7016   float arg2 ;
7017   Dali::Vector4 result;
7018
7019   arg1 = (Dali::Vector4 *)jarg1;
7020   arg2 = (float)jarg2;
7021   {
7022     try {
7023       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7024     } catch (std::out_of_range& e) {
7025       {
7026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7027       };
7028     } catch (std::exception& e) {
7029       {
7030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7031       };
7032     } catch (...) {
7033       {
7034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7035       };
7036     }
7037   }
7038   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7039   return jresult;
7040 }
7041
7042
7043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7044   void * jresult ;
7045   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7046   Dali::Vector4 *arg2 = 0 ;
7047   Dali::Vector4 *result = 0 ;
7048
7049   arg1 = (Dali::Vector4 *)jarg1;
7050   arg2 = (Dali::Vector4 *)jarg2;
7051   if (!arg2) {
7052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7053     return 0;
7054   }
7055   {
7056     try {
7057       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7058     } catch (std::out_of_range& e) {
7059       {
7060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7061       };
7062     } catch (std::exception& e) {
7063       {
7064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7065       };
7066     } catch (...) {
7067       {
7068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7069       };
7070     }
7071   }
7072   jresult = (void *)result;
7073   return jresult;
7074 }
7075
7076
7077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7078   void * jresult ;
7079   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7080   float arg2 ;
7081   Dali::Vector4 *result = 0 ;
7082
7083   arg1 = (Dali::Vector4 *)jarg1;
7084   arg2 = (float)jarg2;
7085   {
7086     try {
7087       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7088     } catch (std::out_of_range& e) {
7089       {
7090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7091       };
7092     } catch (std::exception& e) {
7093       {
7094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7095       };
7096     } catch (...) {
7097       {
7098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7099       };
7100     }
7101   }
7102   jresult = (void *)result;
7103   return jresult;
7104 }
7105
7106
7107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7108   void * jresult ;
7109   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7110   Dali::Vector4 *arg2 = 0 ;
7111   Dali::Vector4 result;
7112
7113   arg1 = (Dali::Vector4 *)jarg1;
7114   arg2 = (Dali::Vector4 *)jarg2;
7115   if (!arg2) {
7116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7117     return 0;
7118   }
7119   {
7120     try {
7121       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7122     } catch (std::out_of_range& e) {
7123       {
7124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7125       };
7126     } catch (std::exception& e) {
7127       {
7128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7129       };
7130     } catch (...) {
7131       {
7132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7133       };
7134     }
7135   }
7136   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7137   return jresult;
7138 }
7139
7140
7141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7142   void * jresult ;
7143   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7144   float arg2 ;
7145   Dali::Vector4 result;
7146
7147   arg1 = (Dali::Vector4 *)jarg1;
7148   arg2 = (float)jarg2;
7149   {
7150     try {
7151       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7152     } catch (std::out_of_range& e) {
7153       {
7154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7155       };
7156     } catch (std::exception& e) {
7157       {
7158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7159       };
7160     } catch (...) {
7161       {
7162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7163       };
7164     }
7165   }
7166   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7167   return jresult;
7168 }
7169
7170
7171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7172   void * jresult ;
7173   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7174   Dali::Vector4 *arg2 = 0 ;
7175   Dali::Vector4 *result = 0 ;
7176
7177   arg1 = (Dali::Vector4 *)jarg1;
7178   arg2 = (Dali::Vector4 *)jarg2;
7179   if (!arg2) {
7180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7181     return 0;
7182   }
7183   {
7184     try {
7185       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7186     } catch (std::out_of_range& e) {
7187       {
7188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7189       };
7190     } catch (std::exception& e) {
7191       {
7192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7193       };
7194     } catch (...) {
7195       {
7196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7197       };
7198     }
7199   }
7200   jresult = (void *)result;
7201   return jresult;
7202 }
7203
7204
7205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7206   void * jresult ;
7207   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7208   float arg2 ;
7209   Dali::Vector4 *result = 0 ;
7210
7211   arg1 = (Dali::Vector4 *)jarg1;
7212   arg2 = (float)jarg2;
7213   {
7214     try {
7215       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7216     } catch (std::out_of_range& e) {
7217       {
7218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7219       };
7220     } catch (std::exception& e) {
7221       {
7222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7223       };
7224     } catch (...) {
7225       {
7226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7227       };
7228     }
7229   }
7230   jresult = (void *)result;
7231   return jresult;
7232 }
7233
7234
7235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7236   void * jresult ;
7237   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7238   Dali::Vector4 result;
7239
7240   arg1 = (Dali::Vector4 *)jarg1;
7241   {
7242     try {
7243       result = ((Dali::Vector4 const *)arg1)->operator -();
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 (...) {
7253       {
7254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7255       };
7256     }
7257   }
7258   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7259   return jresult;
7260 }
7261
7262
7263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7264   unsigned int jresult ;
7265   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7266   Dali::Vector4 *arg2 = 0 ;
7267   bool result;
7268
7269   arg1 = (Dali::Vector4 *)jarg1;
7270   arg2 = (Dali::Vector4 *)jarg2;
7271   if (!arg2) {
7272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7273     return 0;
7274   }
7275   {
7276     try {
7277       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7278     } catch (std::out_of_range& e) {
7279       {
7280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7281       };
7282     } catch (std::exception& e) {
7283       {
7284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7285       };
7286     } catch (...) {
7287       {
7288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7289       };
7290     }
7291   }
7292   jresult = result;
7293   return jresult;
7294 }
7295
7296
7297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7298   unsigned int jresult ;
7299   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7300   Dali::Vector4 *arg2 = 0 ;
7301   bool result;
7302
7303   arg1 = (Dali::Vector4 *)jarg1;
7304   arg2 = (Dali::Vector4 *)jarg2;
7305   if (!arg2) {
7306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7307     return 0;
7308   }
7309   {
7310     try {
7311       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7312     } catch (std::out_of_range& e) {
7313       {
7314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7315       };
7316     } catch (std::exception& e) {
7317       {
7318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7319       };
7320     } catch (...) {
7321       {
7322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7323       };
7324     }
7325   }
7326   jresult = result;
7327   return jresult;
7328 }
7329
7330
7331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7332   float jresult ;
7333   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7334   unsigned int arg2 ;
7335   float *result = 0 ;
7336
7337   arg1 = (Dali::Vector4 *)jarg1;
7338   arg2 = (unsigned int)jarg2;
7339   {
7340     try {
7341       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7342     } catch (std::out_of_range& e) {
7343       {
7344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7345       };
7346     } catch (std::exception& e) {
7347       {
7348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7349       };
7350     } catch (...) {
7351       {
7352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7353       };
7354     }
7355   }
7356   jresult = *result;
7357   return jresult;
7358 }
7359
7360
7361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7362   float jresult ;
7363   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7364   Dali::Vector3 *arg2 = 0 ;
7365   float result;
7366
7367   arg1 = (Dali::Vector4 *)jarg1;
7368   arg2 = (Dali::Vector3 *)jarg2;
7369   if (!arg2) {
7370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7371     return 0;
7372   }
7373   {
7374     try {
7375       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7376     } catch (std::out_of_range& e) {
7377       {
7378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7379       };
7380     } catch (std::exception& e) {
7381       {
7382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7383       };
7384     } catch (...) {
7385       {
7386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7387       };
7388     }
7389   }
7390   jresult = result;
7391   return jresult;
7392 }
7393
7394
7395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7396   float jresult ;
7397   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7398   Dali::Vector4 *arg2 = 0 ;
7399   float result;
7400
7401   arg1 = (Dali::Vector4 *)jarg1;
7402   arg2 = (Dali::Vector4 *)jarg2;
7403   if (!arg2) {
7404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7405     return 0;
7406   }
7407   {
7408     try {
7409       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7410     } catch (std::out_of_range& e) {
7411       {
7412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7413       };
7414     } catch (std::exception& e) {
7415       {
7416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7417       };
7418     } catch (...) {
7419       {
7420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7421       };
7422     }
7423   }
7424   jresult = result;
7425   return jresult;
7426 }
7427
7428
7429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7430   float jresult ;
7431   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7432   Dali::Vector4 *arg2 = 0 ;
7433   float result;
7434
7435   arg1 = (Dali::Vector4 *)jarg1;
7436   arg2 = (Dali::Vector4 *)jarg2;
7437   if (!arg2) {
7438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7439     return 0;
7440   }
7441   {
7442     try {
7443       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7444     } catch (std::out_of_range& e) {
7445       {
7446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7447       };
7448     } catch (std::exception& e) {
7449       {
7450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7451       };
7452     } catch (...) {
7453       {
7454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7455       };
7456     }
7457   }
7458   jresult = result;
7459   return jresult;
7460 }
7461
7462
7463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7464   void * jresult ;
7465   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7466   Dali::Vector4 *arg2 = 0 ;
7467   Dali::Vector4 result;
7468
7469   arg1 = (Dali::Vector4 *)jarg1;
7470   arg2 = (Dali::Vector4 *)jarg2;
7471   if (!arg2) {
7472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7473     return 0;
7474   }
7475   {
7476     try {
7477       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7478     } catch (std::out_of_range& e) {
7479       {
7480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7481       };
7482     } catch (std::exception& e) {
7483       {
7484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7485       };
7486     } catch (...) {
7487       {
7488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7489       };
7490     }
7491   }
7492   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7493   return jresult;
7494 }
7495
7496
7497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7498   float jresult ;
7499   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7500   float result;
7501
7502   arg1 = (Dali::Vector4 *)jarg1;
7503   {
7504     try {
7505       result = (float)((Dali::Vector4 const *)arg1)->Length();
7506     } catch (std::out_of_range& e) {
7507       {
7508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7509       };
7510     } catch (std::exception& e) {
7511       {
7512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7513       };
7514     } catch (...) {
7515       {
7516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7517       };
7518     }
7519   }
7520   jresult = result;
7521   return jresult;
7522 }
7523
7524
7525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7526   float jresult ;
7527   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7528   float result;
7529
7530   arg1 = (Dali::Vector4 *)jarg1;
7531   {
7532     try {
7533       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7534     } catch (std::out_of_range& e) {
7535       {
7536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7537       };
7538     } catch (std::exception& e) {
7539       {
7540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7541       };
7542     } catch (...) {
7543       {
7544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7545       };
7546     }
7547   }
7548   jresult = result;
7549   return jresult;
7550 }
7551
7552
7553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7554   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7555
7556   arg1 = (Dali::Vector4 *)jarg1;
7557   {
7558     try {
7559       (arg1)->Normalize();
7560     } catch (std::out_of_range& e) {
7561       {
7562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7563       };
7564     } catch (std::exception& e) {
7565       {
7566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7567       };
7568     } catch (...) {
7569       {
7570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7571       };
7572     }
7573   }
7574 }
7575
7576
7577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7578   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7579   Dali::Vector4 *arg2 = 0 ;
7580   Dali::Vector4 *arg3 = 0 ;
7581
7582   arg1 = (Dali::Vector4 *)jarg1;
7583   arg2 = (Dali::Vector4 *)jarg2;
7584   if (!arg2) {
7585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7586     return ;
7587   }
7588   arg3 = (Dali::Vector4 *)jarg3;
7589   if (!arg3) {
7590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7591     return ;
7592   }
7593   {
7594     try {
7595       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7596     } catch (std::out_of_range& e) {
7597       {
7598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7599       };
7600     } catch (std::exception& e) {
7601       {
7602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7603       };
7604     } catch (...) {
7605       {
7606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7607       };
7608     }
7609   }
7610 }
7611
7612
7613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7614   void * jresult ;
7615   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7616   float *result = 0 ;
7617
7618   arg1 = (Dali::Vector4 *)jarg1;
7619   {
7620     try {
7621       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7622     } catch (std::out_of_range& e) {
7623       {
7624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7625       };
7626     } catch (std::exception& e) {
7627       {
7628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7629       };
7630     } catch (...) {
7631       {
7632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7633       };
7634     }
7635   }
7636   jresult = (void *)result;
7637   return jresult;
7638 }
7639
7640
7641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7642   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7643   float arg2 ;
7644
7645   arg1 = (Dali::Vector4 *)jarg1;
7646   arg2 = (float)jarg2;
7647   if (arg1) (arg1)->x = arg2;
7648 }
7649
7650
7651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7652   float jresult ;
7653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7654   float result;
7655
7656   arg1 = (Dali::Vector4 *)jarg1;
7657   result = (float) ((arg1)->x);
7658   jresult = result;
7659   return jresult;
7660 }
7661
7662
7663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7664   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7665   float arg2 ;
7666
7667   arg1 = (Dali::Vector4 *)jarg1;
7668   arg2 = (float)jarg2;
7669   if (arg1) (arg1)->r = arg2;
7670 }
7671
7672
7673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7674   float jresult ;
7675   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7676   float result;
7677
7678   arg1 = (Dali::Vector4 *)jarg1;
7679   result = (float) ((arg1)->r);
7680   jresult = result;
7681   return jresult;
7682 }
7683
7684
7685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7686   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7687   float arg2 ;
7688
7689   arg1 = (Dali::Vector4 *)jarg1;
7690   arg2 = (float)jarg2;
7691   if (arg1) (arg1)->s = arg2;
7692 }
7693
7694
7695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7696   float jresult ;
7697   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7698   float result;
7699
7700   arg1 = (Dali::Vector4 *)jarg1;
7701   result = (float) ((arg1)->s);
7702   jresult = result;
7703   return jresult;
7704 }
7705
7706
7707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7708   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7709   float arg2 ;
7710
7711   arg1 = (Dali::Vector4 *)jarg1;
7712   arg2 = (float)jarg2;
7713   if (arg1) (arg1)->y = arg2;
7714 }
7715
7716
7717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7718   float jresult ;
7719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7720   float result;
7721
7722   arg1 = (Dali::Vector4 *)jarg1;
7723   result = (float) ((arg1)->y);
7724   jresult = result;
7725   return jresult;
7726 }
7727
7728
7729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7731   float arg2 ;
7732
7733   arg1 = (Dali::Vector4 *)jarg1;
7734   arg2 = (float)jarg2;
7735   if (arg1) (arg1)->g = arg2;
7736 }
7737
7738
7739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7740   float jresult ;
7741   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7742   float result;
7743
7744   arg1 = (Dali::Vector4 *)jarg1;
7745   result = (float) ((arg1)->g);
7746   jresult = result;
7747   return jresult;
7748 }
7749
7750
7751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7753   float arg2 ;
7754
7755   arg1 = (Dali::Vector4 *)jarg1;
7756   arg2 = (float)jarg2;
7757   if (arg1) (arg1)->t = arg2;
7758 }
7759
7760
7761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7762   float jresult ;
7763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7764   float result;
7765
7766   arg1 = (Dali::Vector4 *)jarg1;
7767   result = (float) ((arg1)->t);
7768   jresult = result;
7769   return jresult;
7770 }
7771
7772
7773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7774   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7775   float arg2 ;
7776
7777   arg1 = (Dali::Vector4 *)jarg1;
7778   arg2 = (float)jarg2;
7779   if (arg1) (arg1)->z = arg2;
7780 }
7781
7782
7783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7784   float jresult ;
7785   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7786   float result;
7787
7788   arg1 = (Dali::Vector4 *)jarg1;
7789   result = (float) ((arg1)->z);
7790   jresult = result;
7791   return jresult;
7792 }
7793
7794
7795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7796   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7797   float arg2 ;
7798
7799   arg1 = (Dali::Vector4 *)jarg1;
7800   arg2 = (float)jarg2;
7801   if (arg1) (arg1)->b = arg2;
7802 }
7803
7804
7805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7806   float jresult ;
7807   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7808   float result;
7809
7810   arg1 = (Dali::Vector4 *)jarg1;
7811   result = (float) ((arg1)->b);
7812   jresult = result;
7813   return jresult;
7814 }
7815
7816
7817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7818   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7819   float arg2 ;
7820
7821   arg1 = (Dali::Vector4 *)jarg1;
7822   arg2 = (float)jarg2;
7823   if (arg1) (arg1)->p = arg2;
7824 }
7825
7826
7827 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7828   float jresult ;
7829   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7830   float result;
7831
7832   arg1 = (Dali::Vector4 *)jarg1;
7833   result = (float) ((arg1)->p);
7834   jresult = result;
7835   return jresult;
7836 }
7837
7838
7839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7840   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7841   float arg2 ;
7842
7843   arg1 = (Dali::Vector4 *)jarg1;
7844   arg2 = (float)jarg2;
7845   if (arg1) (arg1)->w = arg2;
7846 }
7847
7848
7849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7850   float jresult ;
7851   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7852   float result;
7853
7854   arg1 = (Dali::Vector4 *)jarg1;
7855   result = (float) ((arg1)->w);
7856   jresult = result;
7857   return jresult;
7858 }
7859
7860
7861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7862   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7863   float arg2 ;
7864
7865   arg1 = (Dali::Vector4 *)jarg1;
7866   arg2 = (float)jarg2;
7867   if (arg1) (arg1)->a = arg2;
7868 }
7869
7870
7871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7872   float jresult ;
7873   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7874   float result;
7875
7876   arg1 = (Dali::Vector4 *)jarg1;
7877   result = (float) ((arg1)->a);
7878   jresult = result;
7879   return jresult;
7880 }
7881
7882
7883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7884   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7885   float arg2 ;
7886
7887   arg1 = (Dali::Vector4 *)jarg1;
7888   arg2 = (float)jarg2;
7889   if (arg1) (arg1)->q = arg2;
7890 }
7891
7892
7893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7894   float jresult ;
7895   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7896   float result;
7897
7898   arg1 = (Dali::Vector4 *)jarg1;
7899   result = (float) ((arg1)->q);
7900   jresult = result;
7901   return jresult;
7902 }
7903
7904
7905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7906   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7907
7908   arg1 = (Dali::Vector4 *)jarg1;
7909   {
7910     try {
7911       delete arg1;
7912     } catch (std::out_of_range& e) {
7913       {
7914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7915       };
7916     } catch (std::exception& e) {
7917       {
7918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7919       };
7920     } catch (...) {
7921       {
7922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7923       };
7924     }
7925   }
7926 }
7927
7928
7929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7930   void * jresult ;
7931   Dali::Vector4 *arg1 = 0 ;
7932   Dali::Vector4 *arg2 = 0 ;
7933   Dali::Vector4 result;
7934
7935   arg1 = (Dali::Vector4 *)jarg1;
7936   if (!arg1) {
7937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7938     return 0;
7939   }
7940   arg2 = (Dali::Vector4 *)jarg2;
7941   if (!arg2) {
7942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7943     return 0;
7944   }
7945   {
7946     try {
7947       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7948     } catch (std::out_of_range& e) {
7949       {
7950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7951       };
7952     } catch (std::exception& e) {
7953       {
7954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7955       };
7956     } catch (...) {
7957       {
7958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7959       };
7960     }
7961   }
7962   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7963   return jresult;
7964 }
7965
7966
7967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7968   void * jresult ;
7969   Dali::Vector4 *arg1 = 0 ;
7970   Dali::Vector4 *arg2 = 0 ;
7971   Dali::Vector4 result;
7972
7973   arg1 = (Dali::Vector4 *)jarg1;
7974   if (!arg1) {
7975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7976     return 0;
7977   }
7978   arg2 = (Dali::Vector4 *)jarg2;
7979   if (!arg2) {
7980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7981     return 0;
7982   }
7983   {
7984     try {
7985       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7986     } catch (std::out_of_range& e) {
7987       {
7988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7989       };
7990     } catch (std::exception& e) {
7991       {
7992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7993       };
7994     } catch (...) {
7995       {
7996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7997       };
7998     }
7999   }
8000   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8001   return jresult;
8002 }
8003
8004
8005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8006   void * jresult ;
8007   Dali::Vector4 *arg1 = 0 ;
8008   float *arg2 = 0 ;
8009   float *arg3 = 0 ;
8010   float temp2 ;
8011   float temp3 ;
8012   Dali::Vector4 result;
8013
8014   arg1 = (Dali::Vector4 *)jarg1;
8015   if (!arg1) {
8016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8017     return 0;
8018   }
8019   temp2 = (float)jarg2;
8020   arg2 = &temp2;
8021   temp3 = (float)jarg3;
8022   arg3 = &temp3;
8023   {
8024     try {
8025       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8026     } catch (std::out_of_range& e) {
8027       {
8028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8029       };
8030     } catch (std::exception& e) {
8031       {
8032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8033       };
8034     } catch (...) {
8035       {
8036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8037       };
8038     }
8039   }
8040   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8041   return jresult;
8042 }
8043
8044
8045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8046   void * jresult ;
8047   Dali::Uint16Pair *result = 0 ;
8048
8049   {
8050     try {
8051       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8052     } catch (std::out_of_range& e) {
8053       {
8054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8055       };
8056     } catch (std::exception& e) {
8057       {
8058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8059       };
8060     } catch (...) {
8061       {
8062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8063       };
8064     }
8065   }
8066   jresult = (void *)result;
8067   return jresult;
8068 }
8069
8070
8071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8072   void * jresult ;
8073   uint32_t arg1 ;
8074   uint32_t arg2 ;
8075   Dali::Uint16Pair *result = 0 ;
8076
8077   arg1 = (uint32_t)jarg1;
8078   arg2 = (uint32_t)jarg2;
8079   {
8080     try {
8081       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8082     } catch (std::out_of_range& e) {
8083       {
8084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8085       };
8086     } catch (std::exception& e) {
8087       {
8088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8089       };
8090     } catch (...) {
8091       {
8092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8093       };
8094     }
8095   }
8096   jresult = (void *)result;
8097   return jresult;
8098 }
8099
8100
8101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8102   void * jresult ;
8103   Dali::Uint16Pair *arg1 = 0 ;
8104   Dali::Uint16Pair *result = 0 ;
8105
8106   arg1 = (Dali::Uint16Pair *)jarg1;
8107   if (!arg1) {
8108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8109     return 0;
8110   }
8111   {
8112     try {
8113       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8114     } catch (std::out_of_range& e) {
8115       {
8116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8117       };
8118     } catch (std::exception& e) {
8119       {
8120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8121       };
8122     } catch (...) {
8123       {
8124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8125       };
8126     }
8127   }
8128   jresult = (void *)result;
8129   return jresult;
8130 }
8131
8132
8133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8134   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8135   uint16_t arg2 ;
8136
8137   arg1 = (Dali::Uint16Pair *)jarg1;
8138   arg2 = (uint16_t)jarg2;
8139   {
8140     try {
8141       (arg1)->SetWidth(arg2);
8142     } catch (std::out_of_range& e) {
8143       {
8144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8145       };
8146     } catch (std::exception& e) {
8147       {
8148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8149       };
8150     } catch (...) {
8151       {
8152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8153       };
8154     }
8155   }
8156 }
8157
8158
8159 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8160   unsigned short jresult ;
8161   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8162   uint16_t result;
8163
8164   arg1 = (Dali::Uint16Pair *)jarg1;
8165   {
8166     try {
8167       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8168     } catch (std::out_of_range& e) {
8169       {
8170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8171       };
8172     } catch (std::exception& e) {
8173       {
8174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8175       };
8176     } catch (...) {
8177       {
8178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8179       };
8180     }
8181   }
8182   jresult = result;
8183   return jresult;
8184 }
8185
8186
8187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8188   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8189   uint16_t arg2 ;
8190
8191   arg1 = (Dali::Uint16Pair *)jarg1;
8192   arg2 = (uint16_t)jarg2;
8193   {
8194     try {
8195       (arg1)->SetHeight(arg2);
8196     } catch (std::out_of_range& e) {
8197       {
8198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8199       };
8200     } catch (std::exception& e) {
8201       {
8202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8203       };
8204     } catch (...) {
8205       {
8206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8207       };
8208     }
8209   }
8210 }
8211
8212
8213 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8214   unsigned short jresult ;
8215   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8216   uint16_t result;
8217
8218   arg1 = (Dali::Uint16Pair *)jarg1;
8219   {
8220     try {
8221       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8222     } catch (std::out_of_range& e) {
8223       {
8224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8225       };
8226     } catch (std::exception& e) {
8227       {
8228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8229       };
8230     } catch (...) {
8231       {
8232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8233       };
8234     }
8235   }
8236   jresult = result;
8237   return jresult;
8238 }
8239
8240
8241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8242   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8243   uint16_t arg2 ;
8244
8245   arg1 = (Dali::Uint16Pair *)jarg1;
8246   arg2 = (uint16_t)jarg2;
8247   {
8248     try {
8249       (arg1)->SetX(arg2);
8250     } catch (std::out_of_range& e) {
8251       {
8252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8253       };
8254     } catch (std::exception& e) {
8255       {
8256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8257       };
8258     } catch (...) {
8259       {
8260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8261       };
8262     }
8263   }
8264 }
8265
8266
8267 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8268   unsigned short jresult ;
8269   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8270   uint16_t result;
8271
8272   arg1 = (Dali::Uint16Pair *)jarg1;
8273   {
8274     try {
8275       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8276     } catch (std::out_of_range& e) {
8277       {
8278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8279       };
8280     } catch (std::exception& e) {
8281       {
8282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8283       };
8284     } catch (...) {
8285       {
8286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8287       };
8288     }
8289   }
8290   jresult = result;
8291   return jresult;
8292 }
8293
8294
8295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8296   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8297   uint16_t arg2 ;
8298
8299   arg1 = (Dali::Uint16Pair *)jarg1;
8300   arg2 = (uint16_t)jarg2;
8301   {
8302     try {
8303       (arg1)->SetY(arg2);
8304     } catch (std::out_of_range& e) {
8305       {
8306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8307       };
8308     } catch (std::exception& e) {
8309       {
8310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8311       };
8312     } catch (...) {
8313       {
8314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8315       };
8316     }
8317   }
8318 }
8319
8320
8321 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8322   unsigned short jresult ;
8323   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8324   uint16_t result;
8325
8326   arg1 = (Dali::Uint16Pair *)jarg1;
8327   {
8328     try {
8329       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8330     } catch (std::out_of_range& e) {
8331       {
8332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8333       };
8334     } catch (std::exception& e) {
8335       {
8336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8337       };
8338     } catch (...) {
8339       {
8340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8341       };
8342     }
8343   }
8344   jresult = result;
8345   return jresult;
8346 }
8347
8348
8349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8350   void * jresult ;
8351   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8352   Dali::Uint16Pair *arg2 = 0 ;
8353   Dali::Uint16Pair *result = 0 ;
8354
8355   arg1 = (Dali::Uint16Pair *)jarg1;
8356   arg2 = (Dali::Uint16Pair *)jarg2;
8357   if (!arg2) {
8358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8359     return 0;
8360   }
8361   {
8362     try {
8363       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8364     } catch (std::out_of_range& e) {
8365       {
8366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8367       };
8368     } catch (std::exception& e) {
8369       {
8370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8371       };
8372     } catch (...) {
8373       {
8374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8375       };
8376     }
8377   }
8378   jresult = (void *)result;
8379   return jresult;
8380 }
8381
8382
8383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8384   unsigned int jresult ;
8385   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8386   Dali::Uint16Pair *arg2 = 0 ;
8387   bool result;
8388
8389   arg1 = (Dali::Uint16Pair *)jarg1;
8390   arg2 = (Dali::Uint16Pair *)jarg2;
8391   if (!arg2) {
8392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8393     return 0;
8394   }
8395   {
8396     try {
8397       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8398     } catch (std::out_of_range& e) {
8399       {
8400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8401       };
8402     } catch (std::exception& e) {
8403       {
8404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8405       };
8406     } catch (...) {
8407       {
8408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8409       };
8410     }
8411   }
8412   jresult = result;
8413   return jresult;
8414 }
8415
8416
8417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8418   unsigned int jresult ;
8419   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8420   Dali::Uint16Pair *arg2 = 0 ;
8421   bool result;
8422
8423   arg1 = (Dali::Uint16Pair *)jarg1;
8424   arg2 = (Dali::Uint16Pair *)jarg2;
8425   if (!arg2) {
8426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8427     return 0;
8428   }
8429   {
8430     try {
8431       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8432     } catch (std::out_of_range& e) {
8433       {
8434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8435       };
8436     } catch (std::exception& e) {
8437       {
8438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8439       };
8440     } catch (...) {
8441       {
8442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8443       };
8444     }
8445   }
8446   jresult = result;
8447   return jresult;
8448 }
8449
8450
8451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8452   unsigned int jresult ;
8453   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8454   Dali::Uint16Pair *arg2 = 0 ;
8455   bool result;
8456
8457   arg1 = (Dali::Uint16Pair *)jarg1;
8458   arg2 = (Dali::Uint16Pair *)jarg2;
8459   if (!arg2) {
8460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8461     return 0;
8462   }
8463   {
8464     try {
8465       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8466     } catch (std::out_of_range& e) {
8467       {
8468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8469       };
8470     } catch (std::exception& e) {
8471       {
8472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8473       };
8474     } catch (...) {
8475       {
8476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8477       };
8478     }
8479   }
8480   jresult = result;
8481   return jresult;
8482 }
8483
8484
8485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8486   unsigned int jresult ;
8487   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8488   Dali::Uint16Pair *arg2 = 0 ;
8489   bool result;
8490
8491   arg1 = (Dali::Uint16Pair *)jarg1;
8492   arg2 = (Dali::Uint16Pair *)jarg2;
8493   if (!arg2) {
8494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8495     return 0;
8496   }
8497   {
8498     try {
8499       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8500     } catch (std::out_of_range& e) {
8501       {
8502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8503       };
8504     } catch (std::exception& e) {
8505       {
8506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8507       };
8508     } catch (...) {
8509       {
8510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8511       };
8512     }
8513   }
8514   jresult = result;
8515   return jresult;
8516 }
8517
8518
8519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8520   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8521
8522   arg1 = (Dali::Uint16Pair *)jarg1;
8523   {
8524     try {
8525       delete arg1;
8526     } catch (std::out_of_range& e) {
8527       {
8528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8529       };
8530     } catch (std::exception& e) {
8531       {
8532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8533       };
8534     } catch (...) {
8535       {
8536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8537       };
8538     }
8539   }
8540 }
8541
8542
8543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8544   void * jresult ;
8545   Dali::Degree *result = 0 ;
8546
8547   {
8548     try {
8549       result = (Dali::Degree *)new Dali::Degree();
8550     } catch (std::out_of_range& e) {
8551       {
8552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8553       };
8554     } catch (std::exception& e) {
8555       {
8556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8557       };
8558     } catch (...) {
8559       {
8560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8561       };
8562     }
8563   }
8564   jresult = (void *)result;
8565   return jresult;
8566 }
8567
8568
8569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8570   void * jresult ;
8571   float arg1 ;
8572   Dali::Degree *result = 0 ;
8573
8574   arg1 = (float)jarg1;
8575   {
8576     try {
8577       result = (Dali::Degree *)new Dali::Degree(arg1);
8578     } catch (std::out_of_range& e) {
8579       {
8580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8581       };
8582     } catch (std::exception& e) {
8583       {
8584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8585       };
8586     } catch (...) {
8587       {
8588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8589       };
8590     }
8591   }
8592   jresult = (void *)result;
8593   return jresult;
8594 }
8595
8596
8597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8598   void * jresult ;
8599   Dali::Radian arg1 ;
8600   Dali::Radian *argp1 ;
8601   Dali::Degree *result = 0 ;
8602
8603   argp1 = (Dali::Radian *)jarg1;
8604   if (!argp1) {
8605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8606     return 0;
8607   }
8608   arg1 = *argp1;
8609   {
8610     try {
8611       result = (Dali::Degree *)new Dali::Degree(arg1);
8612     } catch (std::out_of_range& e) {
8613       {
8614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8615       };
8616     } catch (std::exception& e) {
8617       {
8618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8619       };
8620     } catch (...) {
8621       {
8622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8623       };
8624     }
8625   }
8626   jresult = (void *)result;
8627   return jresult;
8628 }
8629
8630
8631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8632   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8633   float arg2 ;
8634
8635   arg1 = (Dali::Degree *)jarg1;
8636   arg2 = (float)jarg2;
8637   if (arg1) (arg1)->degree = arg2;
8638 }
8639
8640
8641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8642   float jresult ;
8643   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8644   float result;
8645
8646   arg1 = (Dali::Degree *)jarg1;
8647   result = (float) ((arg1)->degree);
8648   jresult = result;
8649   return jresult;
8650 }
8651
8652
8653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8654   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8655
8656   arg1 = (Dali::Degree *)jarg1;
8657   {
8658     try {
8659       delete arg1;
8660     } catch (std::out_of_range& e) {
8661       {
8662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8663       };
8664     } catch (std::exception& e) {
8665       {
8666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8667       };
8668     } catch (...) {
8669       {
8670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8671       };
8672     }
8673   }
8674 }
8675
8676
8677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8678   void * jresult ;
8679   Dali::Radian *result = 0 ;
8680
8681   result = (Dali::Radian *)&Dali::ANGLE_360;
8682   jresult = (void *)result;
8683   return jresult;
8684 }
8685
8686
8687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8688   void * jresult ;
8689   Dali::Radian *result = 0 ;
8690
8691   result = (Dali::Radian *)&Dali::ANGLE_315;
8692   jresult = (void *)result;
8693   return jresult;
8694 }
8695
8696
8697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8698   void * jresult ;
8699   Dali::Radian *result = 0 ;
8700
8701   result = (Dali::Radian *)&Dali::ANGLE_270;
8702   jresult = (void *)result;
8703   return jresult;
8704 }
8705
8706
8707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8708   void * jresult ;
8709   Dali::Radian *result = 0 ;
8710
8711   result = (Dali::Radian *)&Dali::ANGLE_225;
8712   jresult = (void *)result;
8713   return jresult;
8714 }
8715
8716
8717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8718   void * jresult ;
8719   Dali::Radian *result = 0 ;
8720
8721   result = (Dali::Radian *)&Dali::ANGLE_180;
8722   jresult = (void *)result;
8723   return jresult;
8724 }
8725
8726
8727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8728   void * jresult ;
8729   Dali::Radian *result = 0 ;
8730
8731   result = (Dali::Radian *)&Dali::ANGLE_135;
8732   jresult = (void *)result;
8733   return jresult;
8734 }
8735
8736
8737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8738   void * jresult ;
8739   Dali::Radian *result = 0 ;
8740
8741   result = (Dali::Radian *)&Dali::ANGLE_120;
8742   jresult = (void *)result;
8743   return jresult;
8744 }
8745
8746
8747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8748   void * jresult ;
8749   Dali::Radian *result = 0 ;
8750
8751   result = (Dali::Radian *)&Dali::ANGLE_90;
8752   jresult = (void *)result;
8753   return jresult;
8754 }
8755
8756
8757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8758   void * jresult ;
8759   Dali::Radian *result = 0 ;
8760
8761   result = (Dali::Radian *)&Dali::ANGLE_60;
8762   jresult = (void *)result;
8763   return jresult;
8764 }
8765
8766
8767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8768   void * jresult ;
8769   Dali::Radian *result = 0 ;
8770
8771   result = (Dali::Radian *)&Dali::ANGLE_45;
8772   jresult = (void *)result;
8773   return jresult;
8774 }
8775
8776
8777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8778   void * jresult ;
8779   Dali::Radian *result = 0 ;
8780
8781   result = (Dali::Radian *)&Dali::ANGLE_30;
8782   jresult = (void *)result;
8783   return jresult;
8784 }
8785
8786
8787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8788   void * jresult ;
8789   Dali::Radian *result = 0 ;
8790
8791   result = (Dali::Radian *)&Dali::ANGLE_0;
8792   jresult = (void *)result;
8793   return jresult;
8794 }
8795
8796
8797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8798   unsigned int jresult ;
8799   Dali::Degree *arg1 = 0 ;
8800   Dali::Degree *arg2 = 0 ;
8801   bool result;
8802
8803   arg1 = (Dali::Degree *)jarg1;
8804   if (!arg1) {
8805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8806     return 0;
8807   }
8808   arg2 = (Dali::Degree *)jarg2;
8809   if (!arg2) {
8810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8811     return 0;
8812   }
8813   {
8814     try {
8815       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8816     } catch (std::out_of_range& e) {
8817       {
8818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8819       };
8820     } catch (std::exception& e) {
8821       {
8822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8823       };
8824     } catch (...) {
8825       {
8826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8827       };
8828     }
8829   }
8830   jresult = result;
8831   return jresult;
8832 }
8833
8834
8835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8836   unsigned int jresult ;
8837   Dali::Degree *arg1 = 0 ;
8838   Dali::Degree *arg2 = 0 ;
8839   bool result;
8840
8841   arg1 = (Dali::Degree *)jarg1;
8842   if (!arg1) {
8843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8844     return 0;
8845   }
8846   arg2 = (Dali::Degree *)jarg2;
8847   if (!arg2) {
8848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8849     return 0;
8850   }
8851   {
8852     try {
8853       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8854     } catch (std::out_of_range& e) {
8855       {
8856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8857       };
8858     } catch (std::exception& e) {
8859       {
8860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8861       };
8862     } catch (...) {
8863       {
8864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8865       };
8866     }
8867   }
8868   jresult = result;
8869   return jresult;
8870 }
8871
8872
8873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8874   void * jresult ;
8875   Dali::Degree arg1 ;
8876   float arg2 ;
8877   float arg3 ;
8878   Dali::Degree *argp1 ;
8879   Dali::Degree result;
8880
8881   argp1 = (Dali::Degree *)jarg1;
8882   if (!argp1) {
8883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8884     return 0;
8885   }
8886   arg1 = *argp1;
8887   arg2 = (float)jarg2;
8888   arg3 = (float)jarg3;
8889   {
8890     try {
8891       result = Dali::Clamp(arg1,arg2,arg3);
8892     } catch (std::out_of_range& e) {
8893       {
8894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8895       };
8896     } catch (std::exception& e) {
8897       {
8898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8899       };
8900     } catch (...) {
8901       {
8902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8903       };
8904     }
8905   }
8906   jresult = new Dali::Degree((const Dali::Degree &)result);
8907   return jresult;
8908 }
8909
8910
8911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8912   void * jresult ;
8913   Dali::Radian *result = 0 ;
8914
8915   {
8916     try {
8917       result = (Dali::Radian *)new Dali::Radian();
8918     } catch (std::out_of_range& e) {
8919       {
8920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8921       };
8922     } catch (std::exception& e) {
8923       {
8924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8925       };
8926     } catch (...) {
8927       {
8928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8929       };
8930     }
8931   }
8932   jresult = (void *)result;
8933   return jresult;
8934 }
8935
8936
8937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8938   void * jresult ;
8939   float arg1 ;
8940   Dali::Radian *result = 0 ;
8941
8942   arg1 = (float)jarg1;
8943   {
8944     try {
8945       result = (Dali::Radian *)new Dali::Radian(arg1);
8946     } catch (std::out_of_range& e) {
8947       {
8948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8949       };
8950     } catch (std::exception& e) {
8951       {
8952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8953       };
8954     } catch (...) {
8955       {
8956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8957       };
8958     }
8959   }
8960   jresult = (void *)result;
8961   return jresult;
8962 }
8963
8964
8965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8966   void * jresult ;
8967   Dali::Degree arg1 ;
8968   Dali::Degree *argp1 ;
8969   Dali::Radian *result = 0 ;
8970
8971   argp1 = (Dali::Degree *)jarg1;
8972   if (!argp1) {
8973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8974     return 0;
8975   }
8976   arg1 = *argp1;
8977   {
8978     try {
8979       result = (Dali::Radian *)new Dali::Radian(arg1);
8980     } catch (std::out_of_range& e) {
8981       {
8982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8983       };
8984     } catch (std::exception& e) {
8985       {
8986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8987       };
8988     } catch (...) {
8989       {
8990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8991       };
8992     }
8993   }
8994   jresult = (void *)result;
8995   return jresult;
8996 }
8997
8998
8999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9000   void * jresult ;
9001   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9002   float arg2 ;
9003   Dali::Radian *result = 0 ;
9004
9005   arg1 = (Dali::Radian *)jarg1;
9006   arg2 = (float)jarg2;
9007   {
9008     try {
9009       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9010     } catch (std::out_of_range& e) {
9011       {
9012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9013       };
9014     } catch (std::exception& e) {
9015       {
9016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9017       };
9018     } catch (...) {
9019       {
9020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9021       };
9022     }
9023   }
9024   jresult = (void *)result;
9025   return jresult;
9026 }
9027
9028
9029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9030   void * jresult ;
9031   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9032   Dali::Degree arg2 ;
9033   Dali::Degree *argp2 ;
9034   Dali::Radian *result = 0 ;
9035
9036   arg1 = (Dali::Radian *)jarg1;
9037   argp2 = (Dali::Degree *)jarg2;
9038   if (!argp2) {
9039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9040     return 0;
9041   }
9042   arg2 = *argp2;
9043   {
9044     try {
9045       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9046     } catch (std::out_of_range& e) {
9047       {
9048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9049       };
9050     } catch (std::exception& e) {
9051       {
9052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9053       };
9054     } catch (...) {
9055       {
9056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9057       };
9058     }
9059   }
9060   jresult = (void *)result;
9061   return jresult;
9062 }
9063
9064
9065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9066   float jresult ;
9067   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9068   float result;
9069
9070   arg1 = (Dali::Radian *)jarg1;
9071   {
9072     try {
9073       result = (float)((Dali::Radian const *)arg1)->operator float();
9074     } catch (std::out_of_range& e) {
9075       {
9076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9077       };
9078     } catch (std::exception& e) {
9079       {
9080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9081       };
9082     } catch (...) {
9083       {
9084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9085       };
9086     }
9087   }
9088   jresult = result;
9089   return jresult;
9090 }
9091
9092
9093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9094   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9095   float arg2 ;
9096
9097   arg1 = (Dali::Radian *)jarg1;
9098   arg2 = (float)jarg2;
9099   if (arg1) (arg1)->radian = arg2;
9100 }
9101
9102
9103 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9104   float jresult ;
9105   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9106   float result;
9107
9108   arg1 = (Dali::Radian *)jarg1;
9109   result = (float) ((arg1)->radian);
9110   jresult = result;
9111   return jresult;
9112 }
9113
9114
9115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9116   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9117
9118   arg1 = (Dali::Radian *)jarg1;
9119   {
9120     try {
9121       delete arg1;
9122     } catch (std::out_of_range& e) {
9123       {
9124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9125       };
9126     } catch (std::exception& e) {
9127       {
9128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9129       };
9130     } catch (...) {
9131       {
9132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9133       };
9134     }
9135   }
9136 }
9137
9138
9139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9140   unsigned int jresult ;
9141   Dali::Radian arg1 ;
9142   Dali::Radian arg2 ;
9143   Dali::Radian *argp1 ;
9144   Dali::Radian *argp2 ;
9145   bool result;
9146
9147   argp1 = (Dali::Radian *)jarg1;
9148   if (!argp1) {
9149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9150     return 0;
9151   }
9152   arg1 = *argp1;
9153   argp2 = (Dali::Radian *)jarg2;
9154   if (!argp2) {
9155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9156     return 0;
9157   }
9158   arg2 = *argp2;
9159   {
9160     try {
9161       result = (bool)Dali::operator ==(arg1,arg2);
9162     } catch (std::out_of_range& e) {
9163       {
9164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9165       };
9166     } catch (std::exception& e) {
9167       {
9168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9169       };
9170     } catch (...) {
9171       {
9172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9173       };
9174     }
9175   }
9176   jresult = result;
9177   return jresult;
9178 }
9179
9180
9181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9182   unsigned int jresult ;
9183   Dali::Radian arg1 ;
9184   Dali::Radian arg2 ;
9185   Dali::Radian *argp1 ;
9186   Dali::Radian *argp2 ;
9187   bool result;
9188
9189   argp1 = (Dali::Radian *)jarg1;
9190   if (!argp1) {
9191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9192     return 0;
9193   }
9194   arg1 = *argp1;
9195   argp2 = (Dali::Radian *)jarg2;
9196   if (!argp2) {
9197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9198     return 0;
9199   }
9200   arg2 = *argp2;
9201   {
9202     try {
9203       result = (bool)Dali::operator !=(arg1,arg2);
9204     } catch (std::out_of_range& e) {
9205       {
9206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9207       };
9208     } catch (std::exception& e) {
9209       {
9210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9211       };
9212     } catch (...) {
9213       {
9214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9215       };
9216     }
9217   }
9218   jresult = result;
9219   return jresult;
9220 }
9221
9222
9223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9224   unsigned int jresult ;
9225   Dali::Radian arg1 ;
9226   Dali::Degree arg2 ;
9227   Dali::Radian *argp1 ;
9228   Dali::Degree *argp2 ;
9229   bool result;
9230
9231   argp1 = (Dali::Radian *)jarg1;
9232   if (!argp1) {
9233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9234     return 0;
9235   }
9236   arg1 = *argp1;
9237   argp2 = (Dali::Degree *)jarg2;
9238   if (!argp2) {
9239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9240     return 0;
9241   }
9242   arg2 = *argp2;
9243   {
9244     try {
9245       result = (bool)Dali::operator ==(arg1,arg2);
9246     } catch (std::out_of_range& e) {
9247       {
9248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9249       };
9250     } catch (std::exception& e) {
9251       {
9252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9253       };
9254     } catch (...) {
9255       {
9256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9257       };
9258     }
9259   }
9260   jresult = result;
9261   return jresult;
9262 }
9263
9264
9265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9266   unsigned int jresult ;
9267   Dali::Radian arg1 ;
9268   Dali::Degree arg2 ;
9269   Dali::Radian *argp1 ;
9270   Dali::Degree *argp2 ;
9271   bool result;
9272
9273   argp1 = (Dali::Radian *)jarg1;
9274   if (!argp1) {
9275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9276     return 0;
9277   }
9278   arg1 = *argp1;
9279   argp2 = (Dali::Degree *)jarg2;
9280   if (!argp2) {
9281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9282     return 0;
9283   }
9284   arg2 = *argp2;
9285   {
9286     try {
9287       result = (bool)Dali::operator !=(arg1,arg2);
9288     } catch (std::out_of_range& e) {
9289       {
9290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9291       };
9292     } catch (std::exception& e) {
9293       {
9294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9295       };
9296     } catch (...) {
9297       {
9298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9299       };
9300     }
9301   }
9302   jresult = result;
9303   return jresult;
9304 }
9305
9306
9307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9308   unsigned int jresult ;
9309   Dali::Degree arg1 ;
9310   Dali::Radian arg2 ;
9311   Dali::Degree *argp1 ;
9312   Dali::Radian *argp2 ;
9313   bool result;
9314
9315   argp1 = (Dali::Degree *)jarg1;
9316   if (!argp1) {
9317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9318     return 0;
9319   }
9320   arg1 = *argp1;
9321   argp2 = (Dali::Radian *)jarg2;
9322   if (!argp2) {
9323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9324     return 0;
9325   }
9326   arg2 = *argp2;
9327   {
9328     try {
9329       result = (bool)Dali::operator ==(arg1,arg2);
9330     } catch (std::out_of_range& e) {
9331       {
9332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9333       };
9334     } catch (std::exception& e) {
9335       {
9336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9337       };
9338     } catch (...) {
9339       {
9340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9341       };
9342     }
9343   }
9344   jresult = result;
9345   return jresult;
9346 }
9347
9348
9349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9350   unsigned int jresult ;
9351   Dali::Degree arg1 ;
9352   Dali::Radian arg2 ;
9353   Dali::Degree *argp1 ;
9354   Dali::Radian *argp2 ;
9355   bool result;
9356
9357   argp1 = (Dali::Degree *)jarg1;
9358   if (!argp1) {
9359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9360     return 0;
9361   }
9362   arg1 = *argp1;
9363   argp2 = (Dali::Radian *)jarg2;
9364   if (!argp2) {
9365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9366     return 0;
9367   }
9368   arg2 = *argp2;
9369   {
9370     try {
9371       result = (bool)Dali::operator !=(arg1,arg2);
9372     } catch (std::out_of_range& e) {
9373       {
9374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9375       };
9376     } catch (std::exception& e) {
9377       {
9378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9379       };
9380     } catch (...) {
9381       {
9382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9383       };
9384     }
9385   }
9386   jresult = result;
9387   return jresult;
9388 }
9389
9390
9391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9392   unsigned int jresult ;
9393   Dali::Radian arg1 ;
9394   Dali::Radian arg2 ;
9395   Dali::Radian *argp1 ;
9396   Dali::Radian *argp2 ;
9397   bool result;
9398
9399   argp1 = (Dali::Radian *)jarg1;
9400   if (!argp1) {
9401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9402     return 0;
9403   }
9404   arg1 = *argp1;
9405   argp2 = (Dali::Radian *)jarg2;
9406   if (!argp2) {
9407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9408     return 0;
9409   }
9410   arg2 = *argp2;
9411   {
9412     try {
9413       result = (bool)Dali::operator >(arg1,arg2);
9414     } catch (std::out_of_range& e) {
9415       {
9416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9417       };
9418     } catch (std::exception& e) {
9419       {
9420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9421       };
9422     } catch (...) {
9423       {
9424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9425       };
9426     }
9427   }
9428   jresult = result;
9429   return jresult;
9430 }
9431
9432
9433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9434   unsigned int jresult ;
9435   Dali::Radian arg1 ;
9436   Dali::Degree arg2 ;
9437   Dali::Radian *argp1 ;
9438   Dali::Degree *argp2 ;
9439   bool result;
9440
9441   argp1 = (Dali::Radian *)jarg1;
9442   if (!argp1) {
9443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9444     return 0;
9445   }
9446   arg1 = *argp1;
9447   argp2 = (Dali::Degree *)jarg2;
9448   if (!argp2) {
9449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9450     return 0;
9451   }
9452   arg2 = *argp2;
9453   {
9454     try {
9455       result = (bool)Dali::operator >(arg1,arg2);
9456     } catch (std::out_of_range& e) {
9457       {
9458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9459       };
9460     } catch (std::exception& e) {
9461       {
9462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9463       };
9464     } catch (...) {
9465       {
9466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9467       };
9468     }
9469   }
9470   jresult = result;
9471   return jresult;
9472 }
9473
9474
9475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9476   unsigned int jresult ;
9477   Dali::Degree arg1 ;
9478   Dali::Radian arg2 ;
9479   Dali::Degree *argp1 ;
9480   Dali::Radian *argp2 ;
9481   bool result;
9482
9483   argp1 = (Dali::Degree *)jarg1;
9484   if (!argp1) {
9485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9486     return 0;
9487   }
9488   arg1 = *argp1;
9489   argp2 = (Dali::Radian *)jarg2;
9490   if (!argp2) {
9491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9492     return 0;
9493   }
9494   arg2 = *argp2;
9495   {
9496     try {
9497       result = (bool)Dali::operator >(arg1,arg2);
9498     } catch (std::out_of_range& e) {
9499       {
9500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9501       };
9502     } catch (std::exception& e) {
9503       {
9504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9505       };
9506     } catch (...) {
9507       {
9508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9509       };
9510     }
9511   }
9512   jresult = result;
9513   return jresult;
9514 }
9515
9516
9517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9518   unsigned int jresult ;
9519   Dali::Radian arg1 ;
9520   Dali::Radian arg2 ;
9521   Dali::Radian *argp1 ;
9522   Dali::Radian *argp2 ;
9523   bool result;
9524
9525   argp1 = (Dali::Radian *)jarg1;
9526   if (!argp1) {
9527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9528     return 0;
9529   }
9530   arg1 = *argp1;
9531   argp2 = (Dali::Radian *)jarg2;
9532   if (!argp2) {
9533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9534     return 0;
9535   }
9536   arg2 = *argp2;
9537   {
9538     try {
9539       result = (bool)Dali::operator <(arg1,arg2);
9540     } catch (std::out_of_range& e) {
9541       {
9542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9543       };
9544     } catch (std::exception& e) {
9545       {
9546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9547       };
9548     } catch (...) {
9549       {
9550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9551       };
9552     }
9553   }
9554   jresult = result;
9555   return jresult;
9556 }
9557
9558
9559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9560   unsigned int jresult ;
9561   Dali::Radian arg1 ;
9562   Dali::Degree arg2 ;
9563   Dali::Radian *argp1 ;
9564   Dali::Degree *argp2 ;
9565   bool result;
9566
9567   argp1 = (Dali::Radian *)jarg1;
9568   if (!argp1) {
9569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9570     return 0;
9571   }
9572   arg1 = *argp1;
9573   argp2 = (Dali::Degree *)jarg2;
9574   if (!argp2) {
9575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9576     return 0;
9577   }
9578   arg2 = *argp2;
9579   {
9580     try {
9581       result = (bool)Dali::operator <(arg1,arg2);
9582     } catch (std::out_of_range& e) {
9583       {
9584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9585       };
9586     } catch (std::exception& e) {
9587       {
9588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9589       };
9590     } catch (...) {
9591       {
9592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9593       };
9594     }
9595   }
9596   jresult = result;
9597   return jresult;
9598 }
9599
9600
9601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9602   unsigned int jresult ;
9603   Dali::Degree arg1 ;
9604   Dali::Radian arg2 ;
9605   Dali::Degree *argp1 ;
9606   Dali::Radian *argp2 ;
9607   bool result;
9608
9609   argp1 = (Dali::Degree *)jarg1;
9610   if (!argp1) {
9611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9612     return 0;
9613   }
9614   arg1 = *argp1;
9615   argp2 = (Dali::Radian *)jarg2;
9616   if (!argp2) {
9617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9618     return 0;
9619   }
9620   arg2 = *argp2;
9621   {
9622     try {
9623       result = (bool)Dali::operator <(arg1,arg2);
9624     } catch (std::out_of_range& e) {
9625       {
9626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9627       };
9628     } catch (std::exception& e) {
9629       {
9630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9631       };
9632     } catch (...) {
9633       {
9634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9635       };
9636     }
9637   }
9638   jresult = result;
9639   return jresult;
9640 }
9641
9642
9643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9644   void * jresult ;
9645   Dali::Radian arg1 ;
9646   float arg2 ;
9647   Dali::Radian *argp1 ;
9648   Dali::Radian result;
9649
9650   argp1 = (Dali::Radian *)jarg1;
9651   if (!argp1) {
9652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9653     return 0;
9654   }
9655   arg1 = *argp1;
9656   arg2 = (float)jarg2;
9657   {
9658     try {
9659       result = Dali::operator *(arg1,arg2);
9660     } catch (std::out_of_range& e) {
9661       {
9662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9663       };
9664     } catch (std::exception& e) {
9665       {
9666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9667       };
9668     } catch (...) {
9669       {
9670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9671       };
9672     }
9673   }
9674   jresult = new Dali::Radian((const Dali::Radian &)result);
9675   return jresult;
9676 }
9677
9678
9679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9680   void * jresult ;
9681   Dali::Radian arg1 ;
9682   Dali::Radian *argp1 ;
9683   Dali::Radian result;
9684
9685   argp1 = (Dali::Radian *)jarg1;
9686   if (!argp1) {
9687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9688     return 0;
9689   }
9690   arg1 = *argp1;
9691   {
9692     try {
9693       result = Dali::operator -(arg1);
9694     } catch (std::out_of_range& e) {
9695       {
9696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9697       };
9698     } catch (std::exception& e) {
9699       {
9700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9701       };
9702     } catch (...) {
9703       {
9704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9705       };
9706     }
9707   }
9708   jresult = new Dali::Radian((const Dali::Radian &)result);
9709   return jresult;
9710 }
9711
9712
9713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9714   void * jresult ;
9715   Dali::Radian arg1 ;
9716   float arg2 ;
9717   float arg3 ;
9718   Dali::Radian *argp1 ;
9719   Dali::Radian result;
9720
9721   argp1 = (Dali::Radian *)jarg1;
9722   if (!argp1) {
9723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9724     return 0;
9725   }
9726   arg1 = *argp1;
9727   arg2 = (float)jarg2;
9728   arg3 = (float)jarg3;
9729   {
9730     try {
9731       result = Dali::Clamp(arg1,arg2,arg3);
9732     } catch (std::out_of_range& e) {
9733       {
9734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9735       };
9736     } catch (std::exception& e) {
9737       {
9738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9739       };
9740     } catch (...) {
9741       {
9742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9743       };
9744     }
9745   }
9746   jresult = new Dali::Radian((const Dali::Radian &)result);
9747   return jresult;
9748 }
9749
9750
9751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9752   void * jresult ;
9753   Dali::Quaternion *result = 0 ;
9754
9755   {
9756     try {
9757       result = (Dali::Quaternion *)new Dali::Quaternion();
9758     } catch (std::out_of_range& e) {
9759       {
9760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9761       };
9762     } catch (std::exception& e) {
9763       {
9764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9765       };
9766     } catch (...) {
9767       {
9768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9769       };
9770     }
9771   }
9772   jresult = (void *)result;
9773   return jresult;
9774 }
9775
9776
9777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9778   void * jresult ;
9779   Dali::Radian arg1 ;
9780   Dali::Vector3 *arg2 = 0 ;
9781   Dali::Radian *argp1 ;
9782   Dali::Quaternion *result = 0 ;
9783
9784   argp1 = (Dali::Radian *)jarg1;
9785   if (!argp1) {
9786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9787     return 0;
9788   }
9789   arg1 = *argp1;
9790   arg2 = (Dali::Vector3 *)jarg2;
9791   if (!arg2) {
9792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9793     return 0;
9794   }
9795   {
9796     try {
9797       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9798     } catch (std::out_of_range& e) {
9799       {
9800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9801       };
9802     } catch (std::exception& e) {
9803       {
9804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9805       };
9806     } catch (...) {
9807       {
9808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9809       };
9810     }
9811   }
9812   jresult = (void *)result;
9813   return jresult;
9814 }
9815
9816
9817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9818   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9819
9820   arg1 = (Dali::Quaternion *)jarg1;
9821   {
9822     try {
9823       delete arg1;
9824     } catch (std::out_of_range& e) {
9825       {
9826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9827       };
9828     } catch (std::exception& e) {
9829       {
9830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9831       };
9832     } catch (...) {
9833       {
9834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9835       };
9836     }
9837   }
9838 }
9839
9840
9841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9842   void * jresult ;
9843   Dali::Quaternion *result = 0 ;
9844
9845   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9846   jresult = (void *)result;
9847   return jresult;
9848 }
9849
9850
9851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9852   unsigned int jresult ;
9853   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9854   bool result;
9855
9856   arg1 = (Dali::Quaternion *)jarg1;
9857   {
9858     try {
9859       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9860     } catch (std::out_of_range& e) {
9861       {
9862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9863       };
9864     } catch (std::exception& e) {
9865       {
9866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9867       };
9868     } catch (...) {
9869       {
9870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9871       };
9872     }
9873   }
9874   jresult = result;
9875   return jresult;
9876 }
9877
9878
9879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9880   unsigned int jresult ;
9881   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9882   Dali::Vector3 *arg2 = 0 ;
9883   Dali::Radian *arg3 = 0 ;
9884   bool result;
9885
9886   arg1 = (Dali::Quaternion *)jarg1;
9887   arg2 = (Dali::Vector3 *)jarg2;
9888   if (!arg2) {
9889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9890     return 0;
9891   }
9892   arg3 = (Dali::Radian *)jarg3;
9893   if (!arg3) {
9894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9895     return 0;
9896   }
9897   {
9898     try {
9899       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9900     } catch (std::out_of_range& e) {
9901       {
9902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9903       };
9904     } catch (std::exception& e) {
9905       {
9906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9907       };
9908     } catch (...) {
9909       {
9910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9911       };
9912     }
9913   }
9914   jresult = result;
9915   return jresult;
9916 }
9917
9918
9919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9920   void * jresult ;
9921   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9922   Dali::Quaternion *arg2 = 0 ;
9923   Dali::Quaternion result;
9924
9925   arg1 = (Dali::Quaternion *)jarg1;
9926   arg2 = (Dali::Quaternion *)jarg2;
9927   if (!arg2) {
9928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9929     return 0;
9930   }
9931   {
9932     try {
9933       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9934     } catch (std::out_of_range& e) {
9935       {
9936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9937       };
9938     } catch (std::exception& e) {
9939       {
9940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9941       };
9942     } catch (...) {
9943       {
9944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9945       };
9946     }
9947   }
9948   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9949   return jresult;
9950 }
9951
9952
9953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9954   void * jresult ;
9955   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9956   Dali::Quaternion *arg2 = 0 ;
9957   Dali::Quaternion result;
9958
9959   arg1 = (Dali::Quaternion *)jarg1;
9960   arg2 = (Dali::Quaternion *)jarg2;
9961   if (!arg2) {
9962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9963     return 0;
9964   }
9965   {
9966     try {
9967       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9968     } catch (std::out_of_range& e) {
9969       {
9970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9971       };
9972     } catch (std::exception& e) {
9973       {
9974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9975       };
9976     } catch (...) {
9977       {
9978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9979       };
9980     }
9981   }
9982   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9983   return jresult;
9984 }
9985
9986
9987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
9988   void * jresult ;
9989   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9990   Dali::Quaternion *arg2 = 0 ;
9991   Dali::Quaternion result;
9992
9993   arg1 = (Dali::Quaternion *)jarg1;
9994   arg2 = (Dali::Quaternion *)jarg2;
9995   if (!arg2) {
9996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9997     return 0;
9998   }
9999   {
10000     try {
10001       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10002     } catch (std::out_of_range& e) {
10003       {
10004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10005       };
10006     } catch (std::exception& e) {
10007       {
10008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10009       };
10010     } catch (...) {
10011       {
10012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10013       };
10014     }
10015   }
10016   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10017   return jresult;
10018 }
10019
10020
10021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10022   void * jresult ;
10023   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10024   Dali::Vector3 *arg2 = 0 ;
10025   Dali::Vector3 result;
10026
10027   arg1 = (Dali::Quaternion *)jarg1;
10028   arg2 = (Dali::Vector3 *)jarg2;
10029   if (!arg2) {
10030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10031     return 0;
10032   }
10033   {
10034     try {
10035       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10036     } catch (std::out_of_range& e) {
10037       {
10038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10039       };
10040     } catch (std::exception& e) {
10041       {
10042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10043       };
10044     } catch (...) {
10045       {
10046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10047       };
10048     }
10049   }
10050   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10051   return jresult;
10052 }
10053
10054
10055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10056   void * jresult ;
10057   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10058   Dali::Quaternion *arg2 = 0 ;
10059   Dali::Quaternion result;
10060
10061   arg1 = (Dali::Quaternion *)jarg1;
10062   arg2 = (Dali::Quaternion *)jarg2;
10063   if (!arg2) {
10064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10065     return 0;
10066   }
10067   {
10068     try {
10069       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10070     } catch (std::out_of_range& e) {
10071       {
10072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10073       };
10074     } catch (std::exception& e) {
10075       {
10076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10077       };
10078     } catch (...) {
10079       {
10080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10081       };
10082     }
10083   }
10084   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10085   return jresult;
10086 }
10087
10088
10089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10090   void * jresult ;
10091   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10092   float arg2 ;
10093   Dali::Quaternion result;
10094
10095   arg1 = (Dali::Quaternion *)jarg1;
10096   arg2 = (float)jarg2;
10097   {
10098     try {
10099       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10100     } catch (std::out_of_range& e) {
10101       {
10102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10103       };
10104     } catch (std::exception& e) {
10105       {
10106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10107       };
10108     } catch (...) {
10109       {
10110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10111       };
10112     }
10113   }
10114   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10115   return jresult;
10116 }
10117
10118
10119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10120   void * jresult ;
10121   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10122   float arg2 ;
10123   Dali::Quaternion result;
10124
10125   arg1 = (Dali::Quaternion *)jarg1;
10126   arg2 = (float)jarg2;
10127   {
10128     try {
10129       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10130     } catch (std::out_of_range& e) {
10131       {
10132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10133       };
10134     } catch (std::exception& e) {
10135       {
10136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10137       };
10138     } catch (...) {
10139       {
10140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10141       };
10142     }
10143   }
10144   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10145   return jresult;
10146 }
10147
10148
10149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10150   void * jresult ;
10151   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10152   Dali::Quaternion result;
10153
10154   arg1 = (Dali::Quaternion *)jarg1;
10155   {
10156     try {
10157       result = ((Dali::Quaternion const *)arg1)->operator -();
10158     } catch (std::out_of_range& e) {
10159       {
10160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10161       };
10162     } catch (std::exception& e) {
10163       {
10164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10165       };
10166     } catch (...) {
10167       {
10168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10169       };
10170     }
10171   }
10172   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10173   return jresult;
10174 }
10175
10176
10177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10178   void * jresult ;
10179   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10180   Dali::Quaternion *arg2 = 0 ;
10181   Dali::Quaternion *result = 0 ;
10182
10183   arg1 = (Dali::Quaternion *)jarg1;
10184   arg2 = (Dali::Quaternion *)jarg2;
10185   if (!arg2) {
10186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10187     return 0;
10188   }
10189   {
10190     try {
10191       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10192     } catch (std::out_of_range& e) {
10193       {
10194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10195       };
10196     } catch (std::exception& e) {
10197       {
10198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10199       };
10200     } catch (...) {
10201       {
10202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10203       };
10204     }
10205   }
10206   jresult = (void *)result;
10207   return jresult;
10208 }
10209
10210
10211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10212   void * jresult ;
10213   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10214   Dali::Quaternion *arg2 = 0 ;
10215   Dali::Quaternion *result = 0 ;
10216
10217   arg1 = (Dali::Quaternion *)jarg1;
10218   arg2 = (Dali::Quaternion *)jarg2;
10219   if (!arg2) {
10220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10221     return 0;
10222   }
10223   {
10224     try {
10225       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10226     } catch (std::out_of_range& e) {
10227       {
10228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10229       };
10230     } catch (std::exception& e) {
10231       {
10232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (...) {
10235       {
10236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10237       };
10238     }
10239   }
10240   jresult = (void *)result;
10241   return jresult;
10242 }
10243
10244
10245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10246   void * jresult ;
10247   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10248   Dali::Quaternion *arg2 = 0 ;
10249   Dali::Quaternion *result = 0 ;
10250
10251   arg1 = (Dali::Quaternion *)jarg1;
10252   arg2 = (Dali::Quaternion *)jarg2;
10253   if (!arg2) {
10254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10255     return 0;
10256   }
10257   {
10258     try {
10259       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10260     } catch (std::out_of_range& e) {
10261       {
10262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10263       };
10264     } catch (std::exception& e) {
10265       {
10266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10267       };
10268     } catch (...) {
10269       {
10270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10271       };
10272     }
10273   }
10274   jresult = (void *)result;
10275   return jresult;
10276 }
10277
10278
10279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10280   void * jresult ;
10281   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10282   float arg2 ;
10283   Dali::Quaternion *result = 0 ;
10284
10285   arg1 = (Dali::Quaternion *)jarg1;
10286   arg2 = (float)jarg2;
10287   {
10288     try {
10289       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10290     } catch (std::out_of_range& e) {
10291       {
10292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10293       };
10294     } catch (std::exception& e) {
10295       {
10296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10297       };
10298     } catch (...) {
10299       {
10300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10301       };
10302     }
10303   }
10304   jresult = (void *)result;
10305   return jresult;
10306 }
10307
10308
10309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10310   void * jresult ;
10311   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10312   float arg2 ;
10313   Dali::Quaternion *result = 0 ;
10314
10315   arg1 = (Dali::Quaternion *)jarg1;
10316   arg2 = (float)jarg2;
10317   {
10318     try {
10319       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10320     } catch (std::out_of_range& e) {
10321       {
10322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10323       };
10324     } catch (std::exception& e) {
10325       {
10326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10327       };
10328     } catch (...) {
10329       {
10330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10331       };
10332     }
10333   }
10334   jresult = (void *)result;
10335   return jresult;
10336 }
10337
10338
10339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10340   unsigned int jresult ;
10341   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10342   Dali::Quaternion *arg2 = 0 ;
10343   bool result;
10344
10345   arg1 = (Dali::Quaternion *)jarg1;
10346   arg2 = (Dali::Quaternion *)jarg2;
10347   if (!arg2) {
10348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10349     return 0;
10350   }
10351   {
10352     try {
10353       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10354     } catch (std::out_of_range& e) {
10355       {
10356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10357       };
10358     } catch (std::exception& e) {
10359       {
10360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10361       };
10362     } catch (...) {
10363       {
10364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10365       };
10366     }
10367   }
10368   jresult = result;
10369   return jresult;
10370 }
10371
10372
10373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10374   unsigned int jresult ;
10375   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10376   Dali::Quaternion *arg2 = 0 ;
10377   bool result;
10378
10379   arg1 = (Dali::Quaternion *)jarg1;
10380   arg2 = (Dali::Quaternion *)jarg2;
10381   if (!arg2) {
10382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10383     return 0;
10384   }
10385   {
10386     try {
10387       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10388     } catch (std::out_of_range& e) {
10389       {
10390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10391       };
10392     } catch (std::exception& e) {
10393       {
10394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10395       };
10396     } catch (...) {
10397       {
10398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10399       };
10400     }
10401   }
10402   jresult = result;
10403   return jresult;
10404 }
10405
10406
10407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10408   float jresult ;
10409   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10410   float result;
10411
10412   arg1 = (Dali::Quaternion *)jarg1;
10413   {
10414     try {
10415       result = (float)((Dali::Quaternion const *)arg1)->Length();
10416     } catch (std::out_of_range& e) {
10417       {
10418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10419       };
10420     } catch (std::exception& e) {
10421       {
10422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10423       };
10424     } catch (...) {
10425       {
10426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10427       };
10428     }
10429   }
10430   jresult = result;
10431   return jresult;
10432 }
10433
10434
10435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10436   float jresult ;
10437   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10438   float result;
10439
10440   arg1 = (Dali::Quaternion *)jarg1;
10441   {
10442     try {
10443       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10444     } catch (std::out_of_range& e) {
10445       {
10446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10447       };
10448     } catch (std::exception& e) {
10449       {
10450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10451       };
10452     } catch (...) {
10453       {
10454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10455       };
10456     }
10457   }
10458   jresult = result;
10459   return jresult;
10460 }
10461
10462
10463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10464   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10465
10466   arg1 = (Dali::Quaternion *)jarg1;
10467   {
10468     try {
10469       (arg1)->Normalize();
10470     } catch (std::out_of_range& e) {
10471       {
10472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10473       };
10474     } catch (std::exception& e) {
10475       {
10476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10477       };
10478     } catch (...) {
10479       {
10480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10481       };
10482     }
10483   }
10484 }
10485
10486
10487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10488   void * jresult ;
10489   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10490   Dali::Quaternion result;
10491
10492   arg1 = (Dali::Quaternion *)jarg1;
10493   {
10494     try {
10495       result = ((Dali::Quaternion const *)arg1)->Normalized();
10496     } catch (std::out_of_range& e) {
10497       {
10498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10499       };
10500     } catch (std::exception& e) {
10501       {
10502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10503       };
10504     } catch (...) {
10505       {
10506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10507       };
10508     }
10509   }
10510   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10511   return jresult;
10512 }
10513
10514
10515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10516   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10517
10518   arg1 = (Dali::Quaternion *)jarg1;
10519   {
10520     try {
10521       (arg1)->Conjugate();
10522     } catch (std::out_of_range& e) {
10523       {
10524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10525       };
10526     } catch (std::exception& e) {
10527       {
10528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10529       };
10530     } catch (...) {
10531       {
10532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10533       };
10534     }
10535   }
10536 }
10537
10538
10539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10540   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10541
10542   arg1 = (Dali::Quaternion *)jarg1;
10543   {
10544     try {
10545       (arg1)->Invert();
10546     } catch (std::out_of_range& e) {
10547       {
10548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10549       };
10550     } catch (std::exception& e) {
10551       {
10552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10553       };
10554     } catch (...) {
10555       {
10556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10557       };
10558     }
10559   }
10560 }
10561
10562
10563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10564   void * jresult ;
10565   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10566   Dali::Quaternion result;
10567
10568   arg1 = (Dali::Quaternion *)jarg1;
10569   {
10570     try {
10571       result = ((Dali::Quaternion const *)arg1)->Log();
10572     } catch (std::out_of_range& e) {
10573       {
10574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10575       };
10576     } catch (std::exception& e) {
10577       {
10578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10579       };
10580     } catch (...) {
10581       {
10582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10583       };
10584     }
10585   }
10586   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10587   return jresult;
10588 }
10589
10590
10591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10592   void * jresult ;
10593   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10594   Dali::Quaternion result;
10595
10596   arg1 = (Dali::Quaternion *)jarg1;
10597   {
10598     try {
10599       result = ((Dali::Quaternion const *)arg1)->Exp();
10600     } catch (std::out_of_range& e) {
10601       {
10602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10603       };
10604     } catch (std::exception& e) {
10605       {
10606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10607       };
10608     } catch (...) {
10609       {
10610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10611       };
10612     }
10613   }
10614   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10615   return jresult;
10616 }
10617
10618
10619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10620   float jresult ;
10621   Dali::Quaternion *arg1 = 0 ;
10622   Dali::Quaternion *arg2 = 0 ;
10623   float result;
10624
10625   arg1 = (Dali::Quaternion *)jarg1;
10626   if (!arg1) {
10627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10628     return 0;
10629   }
10630   arg2 = (Dali::Quaternion *)jarg2;
10631   if (!arg2) {
10632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10633     return 0;
10634   }
10635   {
10636     try {
10637       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10638     } catch (std::out_of_range& e) {
10639       {
10640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10641       };
10642     } catch (std::exception& e) {
10643       {
10644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10645       };
10646     } catch (...) {
10647       {
10648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10649       };
10650     }
10651   }
10652   jresult = result;
10653   return jresult;
10654 }
10655
10656
10657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10658   void * jresult ;
10659   Dali::Quaternion *arg1 = 0 ;
10660   Dali::Quaternion *arg2 = 0 ;
10661   float arg3 ;
10662   Dali::Quaternion result;
10663
10664   arg1 = (Dali::Quaternion *)jarg1;
10665   if (!arg1) {
10666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10667     return 0;
10668   }
10669   arg2 = (Dali::Quaternion *)jarg2;
10670   if (!arg2) {
10671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10672     return 0;
10673   }
10674   arg3 = (float)jarg3;
10675   {
10676     try {
10677       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10678     } catch (std::out_of_range& e) {
10679       {
10680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10681       };
10682     } catch (std::exception& e) {
10683       {
10684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10685       };
10686     } catch (...) {
10687       {
10688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10689       };
10690     }
10691   }
10692   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10693   return jresult;
10694 }
10695
10696
10697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10698   void * jresult ;
10699   Dali::Quaternion *arg1 = 0 ;
10700   Dali::Quaternion *arg2 = 0 ;
10701   float arg3 ;
10702   Dali::Quaternion result;
10703
10704   arg1 = (Dali::Quaternion *)jarg1;
10705   if (!arg1) {
10706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10707     return 0;
10708   }
10709   arg2 = (Dali::Quaternion *)jarg2;
10710   if (!arg2) {
10711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10712     return 0;
10713   }
10714   arg3 = (float)jarg3;
10715   {
10716     try {
10717       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10718     } catch (std::out_of_range& e) {
10719       {
10720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10721       };
10722     } catch (std::exception& e) {
10723       {
10724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10725       };
10726     } catch (...) {
10727       {
10728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10729       };
10730     }
10731   }
10732   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10733   return jresult;
10734 }
10735
10736
10737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10738   void * jresult ;
10739   Dali::Quaternion *arg1 = 0 ;
10740   Dali::Quaternion *arg2 = 0 ;
10741   float arg3 ;
10742   Dali::Quaternion result;
10743
10744   arg1 = (Dali::Quaternion *)jarg1;
10745   if (!arg1) {
10746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10747     return 0;
10748   }
10749   arg2 = (Dali::Quaternion *)jarg2;
10750   if (!arg2) {
10751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10752     return 0;
10753   }
10754   arg3 = (float)jarg3;
10755   {
10756     try {
10757       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10758     } catch (std::out_of_range& e) {
10759       {
10760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10761       };
10762     } catch (std::exception& e) {
10763       {
10764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10765       };
10766     } catch (...) {
10767       {
10768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10769       };
10770     }
10771   }
10772   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10773   return jresult;
10774 }
10775
10776
10777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10778   void * jresult ;
10779   Dali::Quaternion *arg1 = 0 ;
10780   Dali::Quaternion *arg2 = 0 ;
10781   Dali::Quaternion *arg3 = 0 ;
10782   Dali::Quaternion *arg4 = 0 ;
10783   float arg5 ;
10784   Dali::Quaternion result;
10785
10786   arg1 = (Dali::Quaternion *)jarg1;
10787   if (!arg1) {
10788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10789     return 0;
10790   }
10791   arg2 = (Dali::Quaternion *)jarg2;
10792   if (!arg2) {
10793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10794     return 0;
10795   }
10796   arg3 = (Dali::Quaternion *)jarg3;
10797   if (!arg3) {
10798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10799     return 0;
10800   }
10801   arg4 = (Dali::Quaternion *)jarg4;
10802   if (!arg4) {
10803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10804     return 0;
10805   }
10806   arg5 = (float)jarg5;
10807   {
10808     try {
10809       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10810     } catch (std::out_of_range& e) {
10811       {
10812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10813       };
10814     } catch (std::exception& e) {
10815       {
10816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10817       };
10818     } catch (...) {
10819       {
10820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10821       };
10822     }
10823   }
10824   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10825   return jresult;
10826 }
10827
10828
10829 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10830   float jresult ;
10831   Dali::Quaternion *arg1 = 0 ;
10832   Dali::Quaternion *arg2 = 0 ;
10833   float result;
10834
10835   arg1 = (Dali::Quaternion *)jarg1;
10836   if (!arg1) {
10837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10838     return 0;
10839   }
10840   arg2 = (Dali::Quaternion *)jarg2;
10841   if (!arg2) {
10842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10843     return 0;
10844   }
10845   {
10846     try {
10847       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10848     } catch (std::out_of_range& e) {
10849       {
10850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10851       };
10852     } catch (std::exception& e) {
10853       {
10854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10855       };
10856     } catch (...) {
10857       {
10858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10859       };
10860     }
10861   }
10862   jresult = result;
10863   return jresult;
10864 }
10865
10866
10867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10868   void * jresult ;
10869   Dali::Matrix *result = 0 ;
10870
10871   {
10872     try {
10873       result = (Dali::Matrix *)new Dali::Matrix();
10874     } catch (std::out_of_range& e) {
10875       {
10876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10877       };
10878     } catch (std::exception& e) {
10879       {
10880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10881       };
10882     } catch (...) {
10883       {
10884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10885       };
10886     }
10887   }
10888   jresult = (void *)result;
10889   return jresult;
10890 }
10891
10892
10893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10894   void * jresult ;
10895   bool arg1 ;
10896   Dali::Matrix *result = 0 ;
10897
10898   arg1 = jarg1 ? true : false;
10899   {
10900     try {
10901       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10902     } catch (std::out_of_range& e) {
10903       {
10904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10905       };
10906     } catch (std::exception& e) {
10907       {
10908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10909       };
10910     } catch (...) {
10911       {
10912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10913       };
10914     }
10915   }
10916   jresult = (void *)result;
10917   return jresult;
10918 }
10919
10920
10921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10922   void * jresult ;
10923   float *arg1 = (float *) 0 ;
10924   Dali::Matrix *result = 0 ;
10925
10926   arg1 = jarg1;
10927   {
10928     try {
10929       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10930     } catch (std::out_of_range& e) {
10931       {
10932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10933       };
10934     } catch (std::exception& e) {
10935       {
10936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10937       };
10938     } catch (...) {
10939       {
10940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10941       };
10942     }
10943   }
10944   jresult = (void *)result;
10945
10946
10947   return jresult;
10948 }
10949
10950
10951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10952   void * jresult ;
10953   Dali::Quaternion *arg1 = 0 ;
10954   Dali::Matrix *result = 0 ;
10955
10956   arg1 = (Dali::Quaternion *)jarg1;
10957   if (!arg1) {
10958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10959     return 0;
10960   }
10961   {
10962     try {
10963       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10964     } catch (std::out_of_range& e) {
10965       {
10966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10967       };
10968     } catch (std::exception& e) {
10969       {
10970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10971       };
10972     } catch (...) {
10973       {
10974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10975       };
10976     }
10977   }
10978   jresult = (void *)result;
10979   return jresult;
10980 }
10981
10982
10983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
10984   void * jresult ;
10985   Dali::Matrix *arg1 = 0 ;
10986   Dali::Matrix *result = 0 ;
10987
10988   arg1 = (Dali::Matrix *)jarg1;
10989   if (!arg1) {
10990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
10991     return 0;
10992   }
10993   {
10994     try {
10995       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
10996     } catch (std::out_of_range& e) {
10997       {
10998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10999       };
11000     } catch (std::exception& e) {
11001       {
11002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11003       };
11004     } catch (...) {
11005       {
11006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11007       };
11008     }
11009   }
11010   jresult = (void *)result;
11011   return jresult;
11012 }
11013
11014
11015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11016   void * jresult ;
11017   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11018   Dali::Matrix *arg2 = 0 ;
11019   Dali::Matrix *result = 0 ;
11020
11021   arg1 = (Dali::Matrix *)jarg1;
11022   arg2 = (Dali::Matrix *)jarg2;
11023   if (!arg2) {
11024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11025     return 0;
11026   }
11027   {
11028     try {
11029       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11030     } catch (std::out_of_range& e) {
11031       {
11032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11033       };
11034     } catch (std::exception& e) {
11035       {
11036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11037       };
11038     } catch (...) {
11039       {
11040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11041       };
11042     }
11043   }
11044   jresult = (void *)result;
11045   return jresult;
11046 }
11047
11048
11049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11050   void * jresult ;
11051   Dali::Matrix *result = 0 ;
11052
11053   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11054   jresult = (void *)result;
11055   return jresult;
11056 }
11057
11058
11059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11060   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11061
11062   arg1 = (Dali::Matrix *)jarg1;
11063   {
11064     try {
11065       (arg1)->SetIdentity();
11066     } catch (std::out_of_range& e) {
11067       {
11068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11069       };
11070     } catch (std::exception& e) {
11071       {
11072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11073       };
11074     } catch (...) {
11075       {
11076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11077       };
11078     }
11079   }
11080 }
11081
11082
11083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11084   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11085   Dali::Vector3 *arg2 = 0 ;
11086
11087   arg1 = (Dali::Matrix *)jarg1;
11088   arg2 = (Dali::Vector3 *)jarg2;
11089   if (!arg2) {
11090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11091     return ;
11092   }
11093   {
11094     try {
11095       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11096     } catch (std::out_of_range& e) {
11097       {
11098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11099       };
11100     } catch (std::exception& e) {
11101       {
11102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11103       };
11104     } catch (...) {
11105       {
11106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11107       };
11108     }
11109   }
11110 }
11111
11112
11113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11114   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11115   Dali::Matrix *arg2 = 0 ;
11116
11117   arg1 = (Dali::Matrix *)jarg1;
11118   arg2 = (Dali::Matrix *)jarg2;
11119   if (!arg2) {
11120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11121     return ;
11122   }
11123   {
11124     try {
11125       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11126     } catch (std::out_of_range& e) {
11127       {
11128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11129       };
11130     } catch (std::exception& e) {
11131       {
11132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11133       };
11134     } catch (...) {
11135       {
11136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11137       };
11138     }
11139   }
11140 }
11141
11142
11143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11144   unsigned int jresult ;
11145   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11146   bool result;
11147
11148   arg1 = (Dali::Matrix *)jarg1;
11149   {
11150     try {
11151       result = (bool)(arg1)->Invert();
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 (...) {
11161       {
11162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11163       };
11164     }
11165   }
11166   jresult = result;
11167   return jresult;
11168 }
11169
11170
11171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11172   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11173
11174   arg1 = (Dali::Matrix *)jarg1;
11175   {
11176     try {
11177       (arg1)->Transpose();
11178     } catch (std::out_of_range& e) {
11179       {
11180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11181       };
11182     } catch (std::exception& e) {
11183       {
11184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11185       };
11186     } catch (...) {
11187       {
11188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11189       };
11190     }
11191   }
11192 }
11193
11194
11195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11196   void * jresult ;
11197   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11198   Dali::Vector3 result;
11199
11200   arg1 = (Dali::Matrix *)jarg1;
11201   {
11202     try {
11203       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11204     } catch (std::out_of_range& e) {
11205       {
11206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11207       };
11208     } catch (std::exception& e) {
11209       {
11210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11211       };
11212     } catch (...) {
11213       {
11214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11215       };
11216     }
11217   }
11218   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11219   return jresult;
11220 }
11221
11222
11223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11224   void * jresult ;
11225   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11226   Dali::Vector3 result;
11227
11228   arg1 = (Dali::Matrix *)jarg1;
11229   {
11230     try {
11231       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11232     } catch (std::out_of_range& e) {
11233       {
11234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11235       };
11236     } catch (std::exception& e) {
11237       {
11238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11239       };
11240     } catch (...) {
11241       {
11242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11243       };
11244     }
11245   }
11246   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11247   return jresult;
11248 }
11249
11250
11251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11252   void * jresult ;
11253   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11254   Dali::Vector3 result;
11255
11256   arg1 = (Dali::Matrix *)jarg1;
11257   {
11258     try {
11259       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11260     } catch (std::out_of_range& e) {
11261       {
11262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11263       };
11264     } catch (std::exception& e) {
11265       {
11266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11267       };
11268     } catch (...) {
11269       {
11270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11271       };
11272     }
11273   }
11274   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11275   return jresult;
11276 }
11277
11278
11279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11280   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11281   Dali::Vector3 *arg2 = 0 ;
11282
11283   arg1 = (Dali::Matrix *)jarg1;
11284   arg2 = (Dali::Vector3 *)jarg2;
11285   if (!arg2) {
11286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11287     return ;
11288   }
11289   {
11290     try {
11291       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11292     } catch (std::out_of_range& e) {
11293       {
11294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11295       };
11296     } catch (std::exception& e) {
11297       {
11298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11299       };
11300     } catch (...) {
11301       {
11302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11303       };
11304     }
11305   }
11306 }
11307
11308
11309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11310   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11311   Dali::Vector3 *arg2 = 0 ;
11312
11313   arg1 = (Dali::Matrix *)jarg1;
11314   arg2 = (Dali::Vector3 *)jarg2;
11315   if (!arg2) {
11316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11317     return ;
11318   }
11319   {
11320     try {
11321       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11322     } catch (std::out_of_range& e) {
11323       {
11324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11325       };
11326     } catch (std::exception& e) {
11327       {
11328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11329       };
11330     } catch (...) {
11331       {
11332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11333       };
11334     }
11335   }
11336 }
11337
11338
11339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11340   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11341   Dali::Vector3 *arg2 = 0 ;
11342
11343   arg1 = (Dali::Matrix *)jarg1;
11344   arg2 = (Dali::Vector3 *)jarg2;
11345   if (!arg2) {
11346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11347     return ;
11348   }
11349   {
11350     try {
11351       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11352     } catch (std::out_of_range& e) {
11353       {
11354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11355       };
11356     } catch (std::exception& e) {
11357       {
11358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11359       };
11360     } catch (...) {
11361       {
11362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11363       };
11364     }
11365   }
11366 }
11367
11368
11369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11370   void * jresult ;
11371   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11372   Dali::Vector4 *result = 0 ;
11373
11374   arg1 = (Dali::Matrix *)jarg1;
11375   {
11376     try {
11377       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11378     } catch (std::out_of_range& e) {
11379       {
11380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11381       };
11382     } catch (std::exception& e) {
11383       {
11384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11385       };
11386     } catch (...) {
11387       {
11388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11389       };
11390     }
11391   }
11392   jresult = (void *)result;
11393   return jresult;
11394 }
11395
11396
11397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11398   void * jresult ;
11399   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11400   Dali::Vector3 *result = 0 ;
11401
11402   arg1 = (Dali::Matrix *)jarg1;
11403   {
11404     try {
11405       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11406     } catch (std::out_of_range& e) {
11407       {
11408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11409       };
11410     } catch (std::exception& e) {
11411       {
11412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11413       };
11414     } catch (...) {
11415       {
11416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11417       };
11418     }
11419   }
11420   jresult = (void *)result;
11421   return jresult;
11422 }
11423
11424
11425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11426   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11427   Dali::Vector4 *arg2 = 0 ;
11428
11429   arg1 = (Dali::Matrix *)jarg1;
11430   arg2 = (Dali::Vector4 *)jarg2;
11431   if (!arg2) {
11432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11433     return ;
11434   }
11435   {
11436     try {
11437       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11438     } catch (std::out_of_range& e) {
11439       {
11440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11441       };
11442     } catch (std::exception& e) {
11443       {
11444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11445       };
11446     } catch (...) {
11447       {
11448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11449       };
11450     }
11451   }
11452 }
11453
11454
11455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11456   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11457   Dali::Vector3 *arg2 = 0 ;
11458
11459   arg1 = (Dali::Matrix *)jarg1;
11460   arg2 = (Dali::Vector3 *)jarg2;
11461   if (!arg2) {
11462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11463     return ;
11464   }
11465   {
11466     try {
11467       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11468     } catch (std::out_of_range& e) {
11469       {
11470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11471       };
11472     } catch (std::exception& e) {
11473       {
11474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11475       };
11476     } catch (...) {
11477       {
11478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11479       };
11480     }
11481   }
11482 }
11483
11484
11485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11486   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11487
11488   arg1 = (Dali::Matrix *)jarg1;
11489   {
11490     try {
11491       (arg1)->OrthoNormalize();
11492     } catch (std::out_of_range& e) {
11493       {
11494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11495       };
11496     } catch (std::exception& e) {
11497       {
11498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11499       };
11500     } catch (...) {
11501       {
11502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11503       };
11504     }
11505   }
11506 }
11507
11508
11509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11510   void * jresult ;
11511   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11512   float *result = 0 ;
11513
11514   arg1 = (Dali::Matrix *)jarg1;
11515   {
11516     try {
11517       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
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 (...) {
11527       {
11528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11529       };
11530     }
11531   }
11532   jresult = (void *)result;
11533   return jresult;
11534 }
11535
11536
11537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11538   Dali::Matrix *arg1 = 0 ;
11539   Dali::Matrix *arg2 = 0 ;
11540   Dali::Matrix *arg3 = 0 ;
11541
11542   arg1 = (Dali::Matrix *)jarg1;
11543   if (!arg1) {
11544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11545     return ;
11546   }
11547   arg2 = (Dali::Matrix *)jarg2;
11548   if (!arg2) {
11549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11550     return ;
11551   }
11552   arg3 = (Dali::Matrix *)jarg3;
11553   if (!arg3) {
11554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11555     return ;
11556   }
11557   {
11558     try {
11559       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11560     } catch (std::out_of_range& e) {
11561       {
11562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11563       };
11564     } catch (std::exception& e) {
11565       {
11566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11567       };
11568     } catch (...) {
11569       {
11570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11571       };
11572     }
11573   }
11574 }
11575
11576
11577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11578   Dali::Matrix *arg1 = 0 ;
11579   Dali::Matrix *arg2 = 0 ;
11580   Dali::Quaternion *arg3 = 0 ;
11581
11582   arg1 = (Dali::Matrix *)jarg1;
11583   if (!arg1) {
11584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11585     return ;
11586   }
11587   arg2 = (Dali::Matrix *)jarg2;
11588   if (!arg2) {
11589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11590     return ;
11591   }
11592   arg3 = (Dali::Quaternion *)jarg3;
11593   if (!arg3) {
11594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11595     return ;
11596   }
11597   {
11598     try {
11599       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11600     } catch (std::out_of_range& e) {
11601       {
11602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11603       };
11604     } catch (std::exception& e) {
11605       {
11606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11607       };
11608     } catch (...) {
11609       {
11610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11611       };
11612     }
11613   }
11614 }
11615
11616
11617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11618   void * jresult ;
11619   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11620   Dali::Vector4 *arg2 = 0 ;
11621   Dali::Vector4 result;
11622
11623   arg1 = (Dali::Matrix *)jarg1;
11624   arg2 = (Dali::Vector4 *)jarg2;
11625   if (!arg2) {
11626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11627     return 0;
11628   }
11629   {
11630     try {
11631       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11632     } catch (std::out_of_range& e) {
11633       {
11634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11635       };
11636     } catch (std::exception& e) {
11637       {
11638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11639       };
11640     } catch (...) {
11641       {
11642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11643       };
11644     }
11645   }
11646   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11647   return jresult;
11648 }
11649
11650
11651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11652   unsigned int jresult ;
11653   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11654   Dali::Matrix *arg2 = 0 ;
11655   bool result;
11656
11657   arg1 = (Dali::Matrix *)jarg1;
11658   arg2 = (Dali::Matrix *)jarg2;
11659   if (!arg2) {
11660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11661     return 0;
11662   }
11663   {
11664     try {
11665       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11666     } catch (std::out_of_range& e) {
11667       {
11668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11669       };
11670     } catch (std::exception& e) {
11671       {
11672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11673       };
11674     } catch (...) {
11675       {
11676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11677       };
11678     }
11679   }
11680   jresult = result;
11681   return jresult;
11682 }
11683
11684
11685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11686   unsigned int jresult ;
11687   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11688   Dali::Matrix *arg2 = 0 ;
11689   bool result;
11690
11691   arg1 = (Dali::Matrix *)jarg1;
11692   arg2 = (Dali::Matrix *)jarg2;
11693   if (!arg2) {
11694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11695     return 0;
11696   }
11697   {
11698     try {
11699       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11700     } catch (std::out_of_range& e) {
11701       {
11702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11703       };
11704     } catch (std::exception& e) {
11705       {
11706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11707       };
11708     } catch (...) {
11709       {
11710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11711       };
11712     }
11713   }
11714   jresult = result;
11715   return jresult;
11716 }
11717
11718
11719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11720   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11721   Dali::Vector3 *arg2 = 0 ;
11722   Dali::Quaternion *arg3 = 0 ;
11723   Dali::Vector3 *arg4 = 0 ;
11724
11725   arg1 = (Dali::Matrix *)jarg1;
11726   arg2 = (Dali::Vector3 *)jarg2;
11727   if (!arg2) {
11728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11729     return ;
11730   }
11731   arg3 = (Dali::Quaternion *)jarg3;
11732   if (!arg3) {
11733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11734     return ;
11735   }
11736   arg4 = (Dali::Vector3 *)jarg4;
11737   if (!arg4) {
11738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11739     return ;
11740   }
11741   {
11742     try {
11743       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11744     } catch (std::out_of_range& e) {
11745       {
11746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11747       };
11748     } catch (std::exception& e) {
11749       {
11750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11751       };
11752     } catch (...) {
11753       {
11754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11755       };
11756     }
11757   }
11758 }
11759
11760
11761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11762   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11763   Dali::Vector3 *arg2 = 0 ;
11764   Dali::Quaternion *arg3 = 0 ;
11765   Dali::Vector3 *arg4 = 0 ;
11766
11767   arg1 = (Dali::Matrix *)jarg1;
11768   arg2 = (Dali::Vector3 *)jarg2;
11769   if (!arg2) {
11770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11771     return ;
11772   }
11773   arg3 = (Dali::Quaternion *)jarg3;
11774   if (!arg3) {
11775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11776     return ;
11777   }
11778   arg4 = (Dali::Vector3 *)jarg4;
11779   if (!arg4) {
11780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11781     return ;
11782   }
11783   {
11784     try {
11785       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11786     } catch (std::out_of_range& e) {
11787       {
11788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11789       };
11790     } catch (std::exception& e) {
11791       {
11792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11793       };
11794     } catch (...) {
11795       {
11796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11797       };
11798     }
11799   }
11800 }
11801
11802
11803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11804   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11805   Dali::Vector3 *arg2 = 0 ;
11806   Dali::Vector3 *arg3 = 0 ;
11807   Dali::Vector3 *arg4 = 0 ;
11808   Dali::Vector3 *arg5 = 0 ;
11809
11810   arg1 = (Dali::Matrix *)jarg1;
11811   arg2 = (Dali::Vector3 *)jarg2;
11812   if (!arg2) {
11813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11814     return ;
11815   }
11816   arg3 = (Dali::Vector3 *)jarg3;
11817   if (!arg3) {
11818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11819     return ;
11820   }
11821   arg4 = (Dali::Vector3 *)jarg4;
11822   if (!arg4) {
11823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11824     return ;
11825   }
11826   arg5 = (Dali::Vector3 *)jarg5;
11827   if (!arg5) {
11828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11829     return ;
11830   }
11831   {
11832     try {
11833       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11834     } catch (std::out_of_range& e) {
11835       {
11836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11837       };
11838     } catch (std::exception& e) {
11839       {
11840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11841       };
11842     } catch (...) {
11843       {
11844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11845       };
11846     }
11847   }
11848 }
11849
11850
11851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11852   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11853   Dali::Vector3 *arg2 = 0 ;
11854   Dali::Quaternion *arg3 = 0 ;
11855   Dali::Vector3 *arg4 = 0 ;
11856
11857   arg1 = (Dali::Matrix *)jarg1;
11858   arg2 = (Dali::Vector3 *)jarg2;
11859   if (!arg2) {
11860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11861     return ;
11862   }
11863   arg3 = (Dali::Quaternion *)jarg3;
11864   if (!arg3) {
11865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11866     return ;
11867   }
11868   arg4 = (Dali::Vector3 *)jarg4;
11869   if (!arg4) {
11870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11871     return ;
11872   }
11873   {
11874     try {
11875       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11876     } catch (std::out_of_range& e) {
11877       {
11878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11879       };
11880     } catch (std::exception& e) {
11881       {
11882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11883       };
11884     } catch (...) {
11885       {
11886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11887       };
11888     }
11889   }
11890 }
11891
11892
11893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11894   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11895
11896   arg1 = (Dali::Matrix *)jarg1;
11897   {
11898     try {
11899       delete arg1;
11900     } catch (std::out_of_range& e) {
11901       {
11902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11903       };
11904     } catch (std::exception& e) {
11905       {
11906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11907       };
11908     } catch (...) {
11909       {
11910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11911       };
11912     }
11913   }
11914 }
11915
11916
11917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11918   void * jresult ;
11919   Dali::Matrix3 *result = 0 ;
11920
11921   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11922   jresult = (void *)result;
11923   return jresult;
11924 }
11925
11926
11927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11928   void * jresult ;
11929   Dali::Matrix3 *result = 0 ;
11930
11931   {
11932     try {
11933       result = (Dali::Matrix3 *)new Dali::Matrix3();
11934     } catch (std::out_of_range& e) {
11935       {
11936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11937       };
11938     } catch (std::exception& e) {
11939       {
11940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11941       };
11942     } catch (...) {
11943       {
11944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11945       };
11946     }
11947   }
11948   jresult = (void *)result;
11949   return jresult;
11950 }
11951
11952
11953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11954   void * jresult ;
11955   Dali::Matrix3 *arg1 = 0 ;
11956   Dali::Matrix3 *result = 0 ;
11957
11958   arg1 = (Dali::Matrix3 *)jarg1;
11959   if (!arg1) {
11960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11961     return 0;
11962   }
11963   {
11964     try {
11965       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11966     } catch (std::out_of_range& e) {
11967       {
11968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11969       };
11970     } catch (std::exception& e) {
11971       {
11972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11973       };
11974     } catch (...) {
11975       {
11976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11977       };
11978     }
11979   }
11980   jresult = (void *)result;
11981   return jresult;
11982 }
11983
11984
11985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
11986   void * jresult ;
11987   Dali::Matrix *arg1 = 0 ;
11988   Dali::Matrix3 *result = 0 ;
11989
11990   arg1 = (Dali::Matrix *)jarg1;
11991   if (!arg1) {
11992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11993     return 0;
11994   }
11995   {
11996     try {
11997       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
11998     } catch (std::out_of_range& e) {
11999       {
12000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12001       };
12002     } catch (std::exception& e) {
12003       {
12004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12005       };
12006     } catch (...) {
12007       {
12008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12009       };
12010     }
12011   }
12012   jresult = (void *)result;
12013   return jresult;
12014 }
12015
12016
12017 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) {
12018   void * jresult ;
12019   float arg1 ;
12020   float arg2 ;
12021   float arg3 ;
12022   float arg4 ;
12023   float arg5 ;
12024   float arg6 ;
12025   float arg7 ;
12026   float arg8 ;
12027   float arg9 ;
12028   Dali::Matrix3 *result = 0 ;
12029
12030   arg1 = (float)jarg1;
12031   arg2 = (float)jarg2;
12032   arg3 = (float)jarg3;
12033   arg4 = (float)jarg4;
12034   arg5 = (float)jarg5;
12035   arg6 = (float)jarg6;
12036   arg7 = (float)jarg7;
12037   arg8 = (float)jarg8;
12038   arg9 = (float)jarg9;
12039   {
12040     try {
12041       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12042     } catch (std::out_of_range& e) {
12043       {
12044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12045       };
12046     } catch (std::exception& e) {
12047       {
12048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12049       };
12050     } catch (...) {
12051       {
12052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12053       };
12054     }
12055   }
12056   jresult = (void *)result;
12057   return jresult;
12058 }
12059
12060
12061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12062   void * jresult ;
12063   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12064   Dali::Matrix3 *arg2 = 0 ;
12065   Dali::Matrix3 *result = 0 ;
12066
12067   arg1 = (Dali::Matrix3 *)jarg1;
12068   arg2 = (Dali::Matrix3 *)jarg2;
12069   if (!arg2) {
12070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12071     return 0;
12072   }
12073   {
12074     try {
12075       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12076     } catch (std::out_of_range& e) {
12077       {
12078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12079       };
12080     } catch (std::exception& e) {
12081       {
12082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12083       };
12084     } catch (...) {
12085       {
12086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12087       };
12088     }
12089   }
12090   jresult = (void *)result;
12091   return jresult;
12092 }
12093
12094
12095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12096   void * jresult ;
12097   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12098   Dali::Matrix *arg2 = 0 ;
12099   Dali::Matrix3 *result = 0 ;
12100
12101   arg1 = (Dali::Matrix3 *)jarg1;
12102   arg2 = (Dali::Matrix *)jarg2;
12103   if (!arg2) {
12104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12105     return 0;
12106   }
12107   {
12108     try {
12109       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12110     } catch (std::out_of_range& e) {
12111       {
12112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12113       };
12114     } catch (std::exception& e) {
12115       {
12116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12117       };
12118     } catch (...) {
12119       {
12120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12121       };
12122     }
12123   }
12124   jresult = (void *)result;
12125   return jresult;
12126 }
12127
12128
12129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12130   unsigned int jresult ;
12131   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12132   Dali::Matrix3 *arg2 = 0 ;
12133   bool result;
12134
12135   arg1 = (Dali::Matrix3 *)jarg1;
12136   arg2 = (Dali::Matrix3 *)jarg2;
12137   if (!arg2) {
12138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12139     return 0;
12140   }
12141   {
12142     try {
12143       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12144     } catch (std::out_of_range& e) {
12145       {
12146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12147       };
12148     } catch (std::exception& e) {
12149       {
12150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12151       };
12152     } catch (...) {
12153       {
12154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12155       };
12156     }
12157   }
12158   jresult = result;
12159   return jresult;
12160 }
12161
12162
12163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12164   unsigned int jresult ;
12165   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12166   Dali::Matrix3 *arg2 = 0 ;
12167   bool result;
12168
12169   arg1 = (Dali::Matrix3 *)jarg1;
12170   arg2 = (Dali::Matrix3 *)jarg2;
12171   if (!arg2) {
12172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12173     return 0;
12174   }
12175   {
12176     try {
12177       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12178     } catch (std::out_of_range& e) {
12179       {
12180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12181       };
12182     } catch (std::exception& e) {
12183       {
12184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12185       };
12186     } catch (...) {
12187       {
12188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12189       };
12190     }
12191   }
12192   jresult = result;
12193   return jresult;
12194 }
12195
12196
12197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12198   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12199
12200   arg1 = (Dali::Matrix3 *)jarg1;
12201   {
12202     try {
12203       delete arg1;
12204     } catch (std::out_of_range& e) {
12205       {
12206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12207       };
12208     } catch (std::exception& e) {
12209       {
12210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12211       };
12212     } catch (...) {
12213       {
12214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12215       };
12216     }
12217   }
12218 }
12219
12220
12221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12222   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12223
12224   arg1 = (Dali::Matrix3 *)jarg1;
12225   {
12226     try {
12227       (arg1)->SetIdentity();
12228     } catch (std::out_of_range& e) {
12229       {
12230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12231       };
12232     } catch (std::exception& e) {
12233       {
12234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12235       };
12236     } catch (...) {
12237       {
12238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12239       };
12240     }
12241   }
12242 }
12243
12244
12245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12246   void * jresult ;
12247   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12248   float *result = 0 ;
12249
12250   arg1 = (Dali::Matrix3 *)jarg1;
12251   {
12252     try {
12253       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12254     } catch (std::out_of_range& e) {
12255       {
12256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12257       };
12258     } catch (std::exception& e) {
12259       {
12260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12261       };
12262     } catch (...) {
12263       {
12264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12265       };
12266     }
12267   }
12268   jresult = (void *)result;
12269   return jresult;
12270 }
12271
12272
12273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12274   unsigned int jresult ;
12275   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12276   bool result;
12277
12278   arg1 = (Dali::Matrix3 *)jarg1;
12279   {
12280     try {
12281       result = (bool)(arg1)->Invert();
12282     } catch (std::out_of_range& e) {
12283       {
12284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12285       };
12286     } catch (std::exception& e) {
12287       {
12288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12289       };
12290     } catch (...) {
12291       {
12292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12293       };
12294     }
12295   }
12296   jresult = result;
12297   return jresult;
12298 }
12299
12300
12301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12302   unsigned int jresult ;
12303   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12304   bool result;
12305
12306   arg1 = (Dali::Matrix3 *)jarg1;
12307   {
12308     try {
12309       result = (bool)(arg1)->Transpose();
12310     } catch (std::out_of_range& e) {
12311       {
12312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12313       };
12314     } catch (std::exception& e) {
12315       {
12316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12317       };
12318     } catch (...) {
12319       {
12320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12321       };
12322     }
12323   }
12324   jresult = result;
12325   return jresult;
12326 }
12327
12328
12329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12330   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12331   float arg2 ;
12332
12333   arg1 = (Dali::Matrix3 *)jarg1;
12334   arg2 = (float)jarg2;
12335   {
12336     try {
12337       (arg1)->Scale(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 (...) {
12347       {
12348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12349       };
12350     }
12351   }
12352 }
12353
12354
12355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12356   float jresult ;
12357   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12358   float result;
12359
12360   arg1 = (Dali::Matrix3 *)jarg1;
12361   {
12362     try {
12363       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12364     } catch (std::out_of_range& e) {
12365       {
12366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12367       };
12368     } catch (std::exception& e) {
12369       {
12370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12371       };
12372     } catch (...) {
12373       {
12374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12375       };
12376     }
12377   }
12378   jresult = result;
12379   return jresult;
12380 }
12381
12382
12383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12384   unsigned int jresult ;
12385   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12386   bool result;
12387
12388   arg1 = (Dali::Matrix3 *)jarg1;
12389   {
12390     try {
12391       result = (bool)(arg1)->ScaledInverseTranspose();
12392     } catch (std::out_of_range& e) {
12393       {
12394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12395       };
12396     } catch (std::exception& e) {
12397       {
12398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12399       };
12400     } catch (...) {
12401       {
12402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12403       };
12404     }
12405   }
12406   jresult = result;
12407   return jresult;
12408 }
12409
12410
12411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12412   Dali::Matrix3 *arg1 = 0 ;
12413   Dali::Matrix3 *arg2 = 0 ;
12414   Dali::Matrix3 *arg3 = 0 ;
12415
12416   arg1 = (Dali::Matrix3 *)jarg1;
12417   if (!arg1) {
12418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12419     return ;
12420   }
12421   arg2 = (Dali::Matrix3 *)jarg2;
12422   if (!arg2) {
12423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12424     return ;
12425   }
12426   arg3 = (Dali::Matrix3 *)jarg3;
12427   if (!arg3) {
12428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12429     return ;
12430   }
12431   {
12432     try {
12433       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12434     } catch (std::out_of_range& e) {
12435       {
12436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12437       };
12438     } catch (std::exception& e) {
12439       {
12440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12441       };
12442     } catch (...) {
12443       {
12444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12445       };
12446     }
12447   }
12448 }
12449
12450
12451 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12452   float jresult ;
12453   float arg1 ;
12454   float arg2 ;
12455   float result;
12456
12457   arg1 = (float)jarg1;
12458   arg2 = (float)jarg2;
12459   {
12460     try {
12461       result = (float)Dali::Random::Range(arg1,arg2);
12462     } catch (std::out_of_range& e) {
12463       {
12464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12465       };
12466     } catch (std::exception& e) {
12467       {
12468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12469       };
12470     } catch (...) {
12471       {
12472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12473       };
12474     }
12475   }
12476   jresult = result;
12477   return jresult;
12478 }
12479
12480
12481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12482   void * jresult ;
12483   Dali::Vector4 result;
12484
12485   {
12486     try {
12487       result = Dali::Random::Axis();
12488     } catch (std::out_of_range& e) {
12489       {
12490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12491       };
12492     } catch (std::exception& e) {
12493       {
12494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12495       };
12496     } catch (...) {
12497       {
12498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12499       };
12500     }
12501   }
12502   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12503   return jresult;
12504 }
12505
12506
12507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12508   void * jresult ;
12509   Dali::AngleAxis *result = 0 ;
12510
12511   {
12512     try {
12513       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12514     } catch (std::out_of_range& e) {
12515       {
12516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12517       };
12518     } catch (std::exception& e) {
12519       {
12520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12521       };
12522     } catch (...) {
12523       {
12524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12525       };
12526     }
12527   }
12528   jresult = (void *)result;
12529   return jresult;
12530 }
12531
12532
12533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12534   void * jresult ;
12535   Dali::Radian arg1 ;
12536   Dali::Vector3 *arg2 = 0 ;
12537   Dali::Radian *argp1 ;
12538   Dali::AngleAxis *result = 0 ;
12539
12540   argp1 = (Dali::Radian *)jarg1;
12541   if (!argp1) {
12542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12543     return 0;
12544   }
12545   arg1 = *argp1;
12546   arg2 = (Dali::Vector3 *)jarg2;
12547   if (!arg2) {
12548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12549     return 0;
12550   }
12551   {
12552     try {
12553       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12554     } catch (std::out_of_range& e) {
12555       {
12556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12557       };
12558     } catch (std::exception& e) {
12559       {
12560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12561       };
12562     } catch (...) {
12563       {
12564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12565       };
12566     }
12567   }
12568   jresult = (void *)result;
12569   return jresult;
12570 }
12571
12572
12573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12574   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12575   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12576
12577   arg1 = (Dali::AngleAxis *)jarg1;
12578   arg2 = (Dali::Radian *)jarg2;
12579   if (arg1) (arg1)->angle = *arg2;
12580 }
12581
12582
12583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12584   void * jresult ;
12585   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12586   Dali::Radian *result = 0 ;
12587
12588   arg1 = (Dali::AngleAxis *)jarg1;
12589   result = (Dali::Radian *)& ((arg1)->angle);
12590   jresult = (void *)result;
12591   return jresult;
12592 }
12593
12594
12595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12596   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12597   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12598
12599   arg1 = (Dali::AngleAxis *)jarg1;
12600   arg2 = (Dali::Vector3 *)jarg2;
12601   if (arg1) (arg1)->axis = *arg2;
12602 }
12603
12604
12605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12606   void * jresult ;
12607   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12608   Dali::Vector3 *result = 0 ;
12609
12610   arg1 = (Dali::AngleAxis *)jarg1;
12611   result = (Dali::Vector3 *)& ((arg1)->axis);
12612   jresult = (void *)result;
12613   return jresult;
12614 }
12615
12616
12617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12618   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12619
12620   arg1 = (Dali::AngleAxis *)jarg1;
12621   {
12622     try {
12623       delete arg1;
12624     } catch (std::out_of_range& e) {
12625       {
12626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12627       };
12628     } catch (std::exception& e) {
12629       {
12630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12631       };
12632     } catch (...) {
12633       {
12634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12635       };
12636     }
12637   }
12638 }
12639
12640
12641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12642   unsigned int jresult ;
12643   Dali::AngleAxis *arg1 = 0 ;
12644   Dali::AngleAxis *arg2 = 0 ;
12645   bool result;
12646
12647   arg1 = (Dali::AngleAxis *)jarg1;
12648   if (!arg1) {
12649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12650     return 0;
12651   }
12652   arg2 = (Dali::AngleAxis *)jarg2;
12653   if (!arg2) {
12654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12655     return 0;
12656   }
12657   {
12658     try {
12659       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12660     } catch (std::out_of_range& e) {
12661       {
12662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12663       };
12664     } catch (std::exception& e) {
12665       {
12666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12667       };
12668     } catch (...) {
12669       {
12670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12671       };
12672     }
12673   }
12674   jresult = result;
12675   return jresult;
12676 }
12677
12678
12679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12680   unsigned int jresult ;
12681   unsigned int arg1 ;
12682   unsigned int result;
12683
12684   arg1 = (unsigned int)jarg1;
12685   {
12686     try {
12687       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12688     } catch (std::out_of_range& e) {
12689       {
12690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12691       };
12692     } catch (std::exception& e) {
12693       {
12694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12695       };
12696     } catch (...) {
12697       {
12698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12699       };
12700     }
12701   }
12702   jresult = result;
12703   return jresult;
12704 }
12705
12706
12707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12708   unsigned int jresult ;
12709   unsigned int arg1 ;
12710   bool result;
12711
12712   arg1 = (unsigned int)jarg1;
12713   {
12714     try {
12715       result = (bool)Dali::IsPowerOfTwo(arg1);
12716     } catch (std::out_of_range& e) {
12717       {
12718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12719       };
12720     } catch (std::exception& e) {
12721       {
12722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12723       };
12724     } catch (...) {
12725       {
12726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12727       };
12728     }
12729   }
12730   jresult = result;
12731   return jresult;
12732 }
12733
12734
12735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12736   float jresult ;
12737   float arg1 ;
12738   float arg2 ;
12739   float result;
12740
12741   arg1 = (float)jarg1;
12742   arg2 = (float)jarg2;
12743   {
12744     try {
12745       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12746     } catch (std::out_of_range& e) {
12747       {
12748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12749       };
12750     } catch (std::exception& e) {
12751       {
12752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12753       };
12754     } catch (...) {
12755       {
12756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12757       };
12758     }
12759   }
12760   jresult = result;
12761   return jresult;
12762 }
12763
12764
12765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12766   unsigned int jresult ;
12767   float arg1 ;
12768   bool result;
12769
12770   arg1 = (float)jarg1;
12771   {
12772     try {
12773       result = (bool)Dali::EqualsZero(arg1);
12774     } catch (std::out_of_range& e) {
12775       {
12776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12777       };
12778     } catch (std::exception& e) {
12779       {
12780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12781       };
12782     } catch (...) {
12783       {
12784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12785       };
12786     }
12787   }
12788   jresult = result;
12789   return jresult;
12790 }
12791
12792
12793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12794   unsigned int jresult ;
12795   float arg1 ;
12796   float arg2 ;
12797   bool result;
12798
12799   arg1 = (float)jarg1;
12800   arg2 = (float)jarg2;
12801   {
12802     try {
12803       result = (bool)Dali::Equals(arg1,arg2);
12804     } catch (std::out_of_range& e) {
12805       {
12806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12807       };
12808     } catch (std::exception& e) {
12809       {
12810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12811       };
12812     } catch (...) {
12813       {
12814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12815       };
12816     }
12817   }
12818   jresult = result;
12819   return jresult;
12820 }
12821
12822
12823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12824   unsigned int jresult ;
12825   float arg1 ;
12826   float arg2 ;
12827   float arg3 ;
12828   bool result;
12829
12830   arg1 = (float)jarg1;
12831   arg2 = (float)jarg2;
12832   arg3 = (float)jarg3;
12833   {
12834     try {
12835       result = (bool)Dali::Equals(arg1,arg2,arg3);
12836     } catch (std::out_of_range& e) {
12837       {
12838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12839       };
12840     } catch (std::exception& e) {
12841       {
12842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12843       };
12844     } catch (...) {
12845       {
12846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12847       };
12848     }
12849   }
12850   jresult = result;
12851   return jresult;
12852 }
12853
12854
12855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12856   float jresult ;
12857   float arg1 ;
12858   int arg2 ;
12859   float result;
12860
12861   arg1 = (float)jarg1;
12862   arg2 = (int)jarg2;
12863   {
12864     try {
12865       result = (float)Dali::Round(arg1,arg2);
12866     } catch (std::out_of_range& e) {
12867       {
12868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12869       };
12870     } catch (std::exception& e) {
12871       {
12872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12873       };
12874     } catch (...) {
12875       {
12876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12877       };
12878     }
12879   }
12880   jresult = result;
12881   return jresult;
12882 }
12883
12884
12885 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12886   float jresult ;
12887   float arg1 ;
12888   float arg2 ;
12889   float arg3 ;
12890   float result;
12891
12892   arg1 = (float)jarg1;
12893   arg2 = (float)jarg2;
12894   arg3 = (float)jarg3;
12895   {
12896     try {
12897       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12898     } catch (std::out_of_range& e) {
12899       {
12900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12901       };
12902     } catch (std::exception& e) {
12903       {
12904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12905       };
12906     } catch (...) {
12907       {
12908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12909       };
12910     }
12911   }
12912   jresult = result;
12913   return jresult;
12914 }
12915
12916
12917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12918   float jresult ;
12919   float arg1 ;
12920   float arg2 ;
12921   float arg3 ;
12922   float arg4 ;
12923   float result;
12924
12925   arg1 = (float)jarg1;
12926   arg2 = (float)jarg2;
12927   arg3 = (float)jarg3;
12928   arg4 = (float)jarg4;
12929   {
12930     try {
12931       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12932     } catch (std::out_of_range& e) {
12933       {
12934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12935       };
12936     } catch (std::exception& e) {
12937       {
12938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12939       };
12940     } catch (...) {
12941       {
12942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12943       };
12944     }
12945   }
12946   jresult = result;
12947   return jresult;
12948 }
12949
12950
12951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12952   int jresult ;
12953   int result;
12954
12955   result = (int)(int)Dali::Property::INVALID_INDEX;
12956   jresult = result;
12957   return jresult;
12958 }
12959
12960
12961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12962   int jresult ;
12963   int result;
12964
12965   result = (int)(int)Dali::Property::INVALID_KEY;
12966   jresult = result;
12967   return jresult;
12968 }
12969
12970
12971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12972   int jresult ;
12973   int result;
12974
12975   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12976   jresult = result;
12977   return jresult;
12978 }
12979
12980
12981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
12982   void * jresult ;
12983   Dali::Handle *arg1 = 0 ;
12984   Dali::Property::Index arg2 ;
12985   Dali::Property *result = 0 ;
12986
12987   arg1 = (Dali::Handle *)jarg1;
12988   if (!arg1) {
12989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
12990     return 0;
12991   }
12992   arg2 = (Dali::Property::Index)jarg2;
12993   {
12994     try {
12995       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
12996     } catch (std::out_of_range& e) {
12997       {
12998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12999       };
13000     } catch (std::exception& e) {
13001       {
13002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13003       };
13004     } catch (...) {
13005       {
13006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13007       };
13008     }
13009   }
13010   jresult = (void *)result;
13011   return jresult;
13012 }
13013
13014
13015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13016   void * jresult ;
13017   Dali::Handle *arg1 = 0 ;
13018   Dali::Property::Index arg2 ;
13019   int arg3 ;
13020   Dali::Property *result = 0 ;
13021
13022   arg1 = (Dali::Handle *)jarg1;
13023   if (!arg1) {
13024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13025     return 0;
13026   }
13027   arg2 = (Dali::Property::Index)jarg2;
13028   arg3 = (int)jarg3;
13029   {
13030     try {
13031       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13032     } catch (std::out_of_range& e) {
13033       {
13034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13035       };
13036     } catch (std::exception& e) {
13037       {
13038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13039       };
13040     } catch (...) {
13041       {
13042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13043       };
13044     }
13045   }
13046   jresult = (void *)result;
13047   return jresult;
13048 }
13049
13050
13051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13052   void * jresult ;
13053   Dali::Handle *arg1 = 0 ;
13054   std::string *arg2 = 0 ;
13055   Dali::Property *result = 0 ;
13056
13057   arg1 = (Dali::Handle *)jarg1;
13058   if (!arg1) {
13059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13060     return 0;
13061   }
13062   if (!jarg2) {
13063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13064     return 0;
13065   }
13066   std::string arg2_str(jarg2);
13067   arg2 = &arg2_str;
13068   {
13069     try {
13070       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13071     } catch (std::out_of_range& e) {
13072       {
13073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13074       };
13075     } catch (std::exception& e) {
13076       {
13077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13078       };
13079     } catch (...) {
13080       {
13081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13082       };
13083     }
13084   }
13085   jresult = (void *)result;
13086
13087   //argout typemap for const std::string&
13088
13089   return jresult;
13090 }
13091
13092
13093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13094   void * jresult ;
13095   Dali::Handle *arg1 = 0 ;
13096   std::string *arg2 = 0 ;
13097   int arg3 ;
13098   Dali::Property *result = 0 ;
13099
13100   arg1 = (Dali::Handle *)jarg1;
13101   if (!arg1) {
13102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13103     return 0;
13104   }
13105   if (!jarg2) {
13106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13107     return 0;
13108   }
13109   std::string arg2_str(jarg2);
13110   arg2 = &arg2_str;
13111   arg3 = (int)jarg3;
13112   {
13113     try {
13114       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13115     } catch (std::out_of_range& e) {
13116       {
13117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13118       };
13119     } catch (std::exception& e) {
13120       {
13121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13122       };
13123     } catch (...) {
13124       {
13125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13126       };
13127     }
13128   }
13129   jresult = (void *)result;
13130
13131   //argout typemap for const std::string&
13132
13133   return jresult;
13134 }
13135
13136
13137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13138   Dali::Property *arg1 = (Dali::Property *) 0 ;
13139
13140   arg1 = (Dali::Property *)jarg1;
13141   {
13142     try {
13143       delete arg1;
13144     } catch (std::out_of_range& e) {
13145       {
13146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13147       };
13148     } catch (std::exception& e) {
13149       {
13150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13151       };
13152     } catch (...) {
13153       {
13154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13155       };
13156     }
13157   }
13158 }
13159
13160
13161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_object__set(void * jarg1, void * jarg2) {
13162   Dali::Property *arg1 = (Dali::Property *) 0 ;
13163   Dali::Handle *arg2 = 0 ;
13164
13165   arg1 = (Dali::Property *)jarg1;
13166   arg2 = (Dali::Handle *)jarg2;
13167   if (!arg2) {
13168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13169     return ;
13170   }
13171   if (arg1) (arg1)->object = *arg2;
13172 }
13173
13174
13175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_object__get(void * jarg1) {
13176   void * jresult ;
13177   Dali::Property *arg1 = (Dali::Property *) 0 ;
13178   Dali::Handle *result = 0 ;
13179
13180   arg1 = (Dali::Property *)jarg1;
13181   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13182   jresult = (void *)result;
13183   return jresult;
13184 }
13185
13186
13187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13188   Dali::Property *arg1 = (Dali::Property *) 0 ;
13189   Dali::Property::Index arg2 ;
13190
13191   arg1 = (Dali::Property *)jarg1;
13192   arg2 = (Dali::Property::Index)jarg2;
13193   if (arg1) (arg1)->propertyIndex = arg2;
13194 }
13195
13196
13197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13198   int jresult ;
13199   Dali::Property *arg1 = (Dali::Property *) 0 ;
13200   Dali::Property::Index result;
13201
13202   arg1 = (Dali::Property *)jarg1;
13203   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13204   jresult = result;
13205   return jresult;
13206 }
13207
13208
13209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13210   Dali::Property *arg1 = (Dali::Property *) 0 ;
13211   int arg2 ;
13212
13213   arg1 = (Dali::Property *)jarg1;
13214   arg2 = (int)jarg2;
13215   if (arg1) (arg1)->componentIndex = arg2;
13216 }
13217
13218
13219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13220   int jresult ;
13221   Dali::Property *arg1 = (Dali::Property *) 0 ;
13222   int result;
13223
13224   arg1 = (Dali::Property *)jarg1;
13225   result = (int) ((arg1)->componentIndex);
13226   jresult = result;
13227   return jresult;
13228 }
13229
13230
13231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13232   void * jresult ;
13233   Dali::Property::Array *result = 0 ;
13234
13235   {
13236     try {
13237       result = (Dali::Property::Array *)new Dali::Property::Array();
13238     } catch (std::out_of_range& e) {
13239       {
13240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13241       };
13242     } catch (std::exception& e) {
13243       {
13244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13245       };
13246     } catch (...) {
13247       {
13248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13249       };
13250     }
13251   }
13252   jresult = (void *)result;
13253   return jresult;
13254 }
13255
13256
13257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13258   void * jresult ;
13259   Dali::Property::Array *arg1 = 0 ;
13260   Dali::Property::Array *result = 0 ;
13261
13262   arg1 = (Dali::Property::Array *)jarg1;
13263   if (!arg1) {
13264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13265     return 0;
13266   }
13267   {
13268     try {
13269       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13270     } catch (std::out_of_range& e) {
13271       {
13272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13273       };
13274     } catch (std::exception& e) {
13275       {
13276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13277       };
13278     } catch (...) {
13279       {
13280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13281       };
13282     }
13283   }
13284   jresult = (void *)result;
13285   return jresult;
13286 }
13287
13288
13289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13290   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13291
13292   arg1 = (Dali::Property::Array *)jarg1;
13293   {
13294     try {
13295       delete arg1;
13296     } catch (std::out_of_range& e) {
13297       {
13298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13299       };
13300     } catch (std::exception& e) {
13301       {
13302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13303       };
13304     } catch (...) {
13305       {
13306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13307       };
13308     }
13309   }
13310 }
13311
13312
13313 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13314   unsigned long jresult ;
13315   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13316   Dali::Property::Array::SizeType result;
13317
13318   arg1 = (Dali::Property::Array *)jarg1;
13319   {
13320     try {
13321       result = ((Dali::Property::Array const *)arg1)->Size();
13322     } catch (std::out_of_range& e) {
13323       {
13324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13325       };
13326     } catch (std::exception& e) {
13327       {
13328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13329       };
13330     } catch (...) {
13331       {
13332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13333       };
13334     }
13335   }
13336   jresult = (unsigned long)result;
13337   return jresult;
13338 }
13339
13340
13341 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13342   unsigned long jresult ;
13343   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13344   Dali::Property::Array::SizeType result;
13345
13346   arg1 = (Dali::Property::Array *)jarg1;
13347   {
13348     try {
13349       result = ((Dali::Property::Array const *)arg1)->Count();
13350     } catch (std::out_of_range& e) {
13351       {
13352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13353       };
13354     } catch (std::exception& e) {
13355       {
13356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13357       };
13358     } catch (...) {
13359       {
13360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13361       };
13362     }
13363   }
13364   jresult = (unsigned long)result;
13365   return jresult;
13366 }
13367
13368
13369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13370   unsigned int jresult ;
13371   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13372   bool result;
13373
13374   arg1 = (Dali::Property::Array *)jarg1;
13375   {
13376     try {
13377       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13378     } catch (std::out_of_range& e) {
13379       {
13380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13381       };
13382     } catch (std::exception& e) {
13383       {
13384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13385       };
13386     } catch (...) {
13387       {
13388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13389       };
13390     }
13391   }
13392   jresult = result;
13393   return jresult;
13394 }
13395
13396
13397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13398   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13399
13400   arg1 = (Dali::Property::Array *)jarg1;
13401   {
13402     try {
13403       (arg1)->Clear();
13404     } catch (std::out_of_range& e) {
13405       {
13406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13407       };
13408     } catch (std::exception& e) {
13409       {
13410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13411       };
13412     } catch (...) {
13413       {
13414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13415       };
13416     }
13417   }
13418 }
13419
13420
13421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13422   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13423   Dali::Property::Array::SizeType arg2 ;
13424
13425   arg1 = (Dali::Property::Array *)jarg1;
13426   arg2 = (Dali::Property::Array::SizeType)jarg2;
13427   {
13428     try {
13429       (arg1)->Reserve(arg2);
13430     } catch (std::out_of_range& e) {
13431       {
13432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13433       };
13434     } catch (std::exception& e) {
13435       {
13436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13437       };
13438     } catch (...) {
13439       {
13440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13441       };
13442     }
13443   }
13444 }
13445
13446
13447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13448   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13449   Dali::Property::Array::SizeType arg2 ;
13450
13451   arg1 = (Dali::Property::Array *)jarg1;
13452   arg2 = (Dali::Property::Array::SizeType)jarg2;
13453   {
13454     try {
13455       (arg1)->Resize(arg2);
13456     } catch (std::out_of_range& e) {
13457       {
13458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13459       };
13460     } catch (std::exception& e) {
13461       {
13462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13463       };
13464     } catch (...) {
13465       {
13466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13467       };
13468     }
13469   }
13470 }
13471
13472
13473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13474   unsigned long jresult ;
13475   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13476   Dali::Property::Array::SizeType result;
13477
13478   arg1 = (Dali::Property::Array *)jarg1;
13479   {
13480     try {
13481       result = (arg1)->Capacity();
13482     } catch (std::out_of_range& e) {
13483       {
13484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13485       };
13486     } catch (std::exception& e) {
13487       {
13488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13489       };
13490     } catch (...) {
13491       {
13492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13493       };
13494     }
13495   }
13496   jresult = (unsigned long)result;
13497   return jresult;
13498 }
13499
13500
13501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13502   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13503   Dali::Property::Value *arg2 = 0 ;
13504
13505   arg1 = (Dali::Property::Array *)jarg1;
13506   arg2 = (Dali::Property::Value *)jarg2;
13507   if (!arg2) {
13508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13509     return ;
13510   }
13511   {
13512     try {
13513       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13514     } catch (std::out_of_range& e) {
13515       {
13516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13517       };
13518     } catch (std::exception& e) {
13519       {
13520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13521       };
13522     } catch (...) {
13523       {
13524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13525       };
13526     }
13527   }
13528 }
13529
13530
13531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13532   void * jresult ;
13533   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13534   Dali::Property::Value *arg2 = 0 ;
13535   Dali::Property::Array *result = 0 ;
13536
13537   arg1 = (Dali::Property::Array *)jarg1;
13538   arg2 = (Dali::Property::Value *)jarg2;
13539   if (!arg2) {
13540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13541     return 0;
13542   }
13543   {
13544     try {
13545       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13546     } catch (std::out_of_range& e) {
13547       {
13548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13549       };
13550     } catch (std::exception& e) {
13551       {
13552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13553       };
13554     } catch (...) {
13555       {
13556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13557       };
13558     }
13559   }
13560   jresult = (void *)result;
13561   return jresult;
13562 }
13563
13564
13565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13566   void * jresult ;
13567   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13568   Dali::Property::Array::SizeType arg2 ;
13569   Dali::Property::Value *result = 0 ;
13570
13571   arg1 = (Dali::Property::Array *)jarg1;
13572   arg2 = (Dali::Property::Array::SizeType)jarg2;
13573   {
13574     try {
13575       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13576     } catch (std::out_of_range& e) {
13577       {
13578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13579       };
13580     } catch (std::exception& e) {
13581       {
13582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13583       };
13584     } catch (...) {
13585       {
13586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13587       };
13588     }
13589   }
13590   jresult = (void *)result;
13591   return jresult;
13592 }
13593
13594
13595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13596   void * jresult ;
13597   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13598   Dali::Property::Array::SizeType arg2 ;
13599   Dali::Property::Value *result = 0 ;
13600
13601   arg1 = (Dali::Property::Array *)jarg1;
13602   arg2 = (Dali::Property::Array::SizeType)jarg2;
13603   {
13604     try {
13605       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13606     } catch (std::out_of_range& e) {
13607       {
13608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13609       };
13610     } catch (std::exception& e) {
13611       {
13612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13613       };
13614     } catch (...) {
13615       {
13616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13617       };
13618     }
13619   }
13620   jresult = (void *)result;
13621   return jresult;
13622 }
13623
13624
13625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13626   void * jresult ;
13627   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13628   Dali::Property::Array *arg2 = 0 ;
13629   Dali::Property::Array *result = 0 ;
13630
13631   arg1 = (Dali::Property::Array *)jarg1;
13632   arg2 = (Dali::Property::Array *)jarg2;
13633   if (!arg2) {
13634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13635     return 0;
13636   }
13637   {
13638     try {
13639       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13640     } catch (std::out_of_range& e) {
13641       {
13642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13643       };
13644     } catch (std::exception& e) {
13645       {
13646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13647       };
13648     } catch (...) {
13649       {
13650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13651       };
13652     }
13653   }
13654   jresult = (void *)result;
13655   return jresult;
13656 }
13657
13658
13659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13660   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13661   enum Dali::Property::Key::Type arg2 ;
13662
13663   arg1 = (Dali::Property::Key *)jarg1;
13664   arg2 = (enum Dali::Property::Key::Type)jarg2;
13665   if (arg1) (arg1)->type = arg2;
13666 }
13667
13668
13669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13670   int jresult ;
13671   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13672   enum Dali::Property::Key::Type result;
13673
13674   arg1 = (Dali::Property::Key *)jarg1;
13675   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13676   jresult = (int)result;
13677   return jresult;
13678 }
13679
13680
13681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13682   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13683   Dali::Property::Index arg2 ;
13684
13685   arg1 = (Dali::Property::Key *)jarg1;
13686   arg2 = (Dali::Property::Index)jarg2;
13687   if (arg1) (arg1)->indexKey = arg2;
13688 }
13689
13690
13691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13692   int jresult ;
13693   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13694   Dali::Property::Index result;
13695
13696   arg1 = (Dali::Property::Key *)jarg1;
13697   result = (Dali::Property::Index) ((arg1)->indexKey);
13698   jresult = result;
13699   return jresult;
13700 }
13701
13702
13703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13704   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13705   std::string *arg2 = 0 ;
13706
13707   arg1 = (Dali::Property::Key *)jarg1;
13708   if (!jarg2) {
13709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13710     return ;
13711   }
13712   std::string arg2_str(jarg2);
13713   arg2 = &arg2_str;
13714   if (arg1) (arg1)->stringKey = *arg2;
13715
13716   //argout typemap for const std::string&
13717
13718 }
13719
13720
13721 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13722   char * jresult ;
13723   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13724   std::string *result = 0 ;
13725
13726   arg1 = (Dali::Property::Key *)jarg1;
13727   result = (std::string *) & ((arg1)->stringKey);
13728   jresult = SWIG_csharp_string_callback(result->c_str());
13729   return jresult;
13730 }
13731
13732
13733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13734   void * jresult ;
13735   std::string *arg1 = 0 ;
13736   Dali::Property::Key *result = 0 ;
13737
13738   if (!jarg1) {
13739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13740     return 0;
13741   }
13742   std::string arg1_str(jarg1);
13743   arg1 = &arg1_str;
13744   {
13745     try {
13746       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13747     } catch (std::out_of_range& e) {
13748       {
13749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13750       };
13751     } catch (std::exception& e) {
13752       {
13753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13754       };
13755     } catch (...) {
13756       {
13757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13758       };
13759     }
13760   }
13761   jresult = (void *)result;
13762
13763   //argout typemap for const std::string&
13764
13765   return jresult;
13766 }
13767
13768
13769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13770   void * jresult ;
13771   Dali::Property::Index arg1 ;
13772   Dali::Property::Key *result = 0 ;
13773
13774   arg1 = (Dali::Property::Index)jarg1;
13775   {
13776     try {
13777       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13778     } catch (std::out_of_range& e) {
13779       {
13780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13781       };
13782     } catch (std::exception& e) {
13783       {
13784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13785       };
13786     } catch (...) {
13787       {
13788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13789       };
13790     }
13791   }
13792   jresult = (void *)result;
13793   return jresult;
13794 }
13795
13796
13797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13798   unsigned int jresult ;
13799   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13800   std::string *arg2 = 0 ;
13801   bool result;
13802
13803   arg1 = (Dali::Property::Key *)jarg1;
13804   if (!jarg2) {
13805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13806     return 0;
13807   }
13808   std::string arg2_str(jarg2);
13809   arg2 = &arg2_str;
13810   {
13811     try {
13812       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13813     } catch (std::out_of_range& e) {
13814       {
13815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13816       };
13817     } catch (std::exception& e) {
13818       {
13819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13820       };
13821     } catch (...) {
13822       {
13823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13824       };
13825     }
13826   }
13827   jresult = result;
13828
13829   //argout typemap for const std::string&
13830
13831   return jresult;
13832 }
13833
13834
13835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13836   unsigned int jresult ;
13837   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13838   Dali::Property::Index arg2 ;
13839   bool result;
13840
13841   arg1 = (Dali::Property::Key *)jarg1;
13842   arg2 = (Dali::Property::Index)jarg2;
13843   {
13844     try {
13845       result = (bool)(arg1)->operator ==(arg2);
13846     } catch (std::out_of_range& e) {
13847       {
13848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13849       };
13850     } catch (std::exception& e) {
13851       {
13852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13853       };
13854     } catch (...) {
13855       {
13856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13857       };
13858     }
13859   }
13860   jresult = result;
13861   return jresult;
13862 }
13863
13864
13865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13866   unsigned int jresult ;
13867   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13868   Dali::Property::Key *arg2 = 0 ;
13869   bool result;
13870
13871   arg1 = (Dali::Property::Key *)jarg1;
13872   arg2 = (Dali::Property::Key *)jarg2;
13873   if (!arg2) {
13874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13875     return 0;
13876   }
13877   {
13878     try {
13879       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13880     } catch (std::out_of_range& e) {
13881       {
13882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13883       };
13884     } catch (std::exception& e) {
13885       {
13886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13887       };
13888     } catch (...) {
13889       {
13890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13891       };
13892     }
13893   }
13894   jresult = result;
13895   return jresult;
13896 }
13897
13898
13899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13900   unsigned int jresult ;
13901   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13902   std::string *arg2 = 0 ;
13903   bool result;
13904
13905   arg1 = (Dali::Property::Key *)jarg1;
13906   if (!jarg2) {
13907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13908     return 0;
13909   }
13910   std::string arg2_str(jarg2);
13911   arg2 = &arg2_str;
13912   {
13913     try {
13914       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
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 (...) {
13924       {
13925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13926       };
13927     }
13928   }
13929   jresult = result;
13930
13931   //argout typemap for const std::string&
13932
13933   return jresult;
13934 }
13935
13936
13937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13938   unsigned int jresult ;
13939   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13940   Dali::Property::Index arg2 ;
13941   bool result;
13942
13943   arg1 = (Dali::Property::Key *)jarg1;
13944   arg2 = (Dali::Property::Index)jarg2;
13945   {
13946     try {
13947       result = (bool)(arg1)->operator !=(arg2);
13948     } catch (std::out_of_range& e) {
13949       {
13950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13951       };
13952     } catch (std::exception& e) {
13953       {
13954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13955       };
13956     } catch (...) {
13957       {
13958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13959       };
13960     }
13961   }
13962   jresult = result;
13963   return jresult;
13964 }
13965
13966
13967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13968   unsigned int jresult ;
13969   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13970   Dali::Property::Key *arg2 = 0 ;
13971   bool result;
13972
13973   arg1 = (Dali::Property::Key *)jarg1;
13974   arg2 = (Dali::Property::Key *)jarg2;
13975   if (!arg2) {
13976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13977     return 0;
13978   }
13979   {
13980     try {
13981       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
13982     } catch (std::out_of_range& e) {
13983       {
13984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13985       };
13986     } catch (std::exception& e) {
13987       {
13988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13989       };
13990     } catch (...) {
13991       {
13992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13993       };
13994     }
13995   }
13996   jresult = result;
13997   return jresult;
13998 }
13999
14000
14001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14002   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14003
14004   arg1 = (Dali::Property::Key *)jarg1;
14005   {
14006     try {
14007       delete arg1;
14008     } catch (std::out_of_range& e) {
14009       {
14010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14011       };
14012     } catch (std::exception& e) {
14013       {
14014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14015       };
14016     } catch (...) {
14017       {
14018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14019       };
14020     }
14021   }
14022 }
14023
14024
14025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14026   void * jresult ;
14027   Dali::Property::Map *result = 0 ;
14028
14029   {
14030     try {
14031       result = (Dali::Property::Map *)new Dali::Property::Map();
14032     } catch (std::out_of_range& e) {
14033       {
14034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14035       };
14036     } catch (std::exception& e) {
14037       {
14038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14039       };
14040     } catch (...) {
14041       {
14042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14043       };
14044     }
14045   }
14046   jresult = (void *)result;
14047   return jresult;
14048 }
14049
14050
14051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14052   void * jresult ;
14053   Dali::Property::Map *arg1 = 0 ;
14054   Dali::Property::Map *result = 0 ;
14055
14056   arg1 = (Dali::Property::Map *)jarg1;
14057   if (!arg1) {
14058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14059     return 0;
14060   }
14061   {
14062     try {
14063       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14064     } catch (std::out_of_range& e) {
14065       {
14066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14067       };
14068     } catch (std::exception& e) {
14069       {
14070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14071       };
14072     } catch (...) {
14073       {
14074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14075       };
14076     }
14077   }
14078   jresult = (void *)result;
14079   return jresult;
14080 }
14081
14082
14083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14084   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14085
14086   arg1 = (Dali::Property::Map *)jarg1;
14087   {
14088     try {
14089       delete arg1;
14090     } catch (std::out_of_range& e) {
14091       {
14092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14093       };
14094     } catch (std::exception& e) {
14095       {
14096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14097       };
14098     } catch (...) {
14099       {
14100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14101       };
14102     }
14103   }
14104 }
14105
14106
14107 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14108   unsigned long jresult ;
14109   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14110   Dali::Property::Map::SizeType result;
14111
14112   arg1 = (Dali::Property::Map *)jarg1;
14113   {
14114     try {
14115       result = ((Dali::Property::Map const *)arg1)->Count();
14116     } catch (std::out_of_range& e) {
14117       {
14118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14119       };
14120     } catch (std::exception& e) {
14121       {
14122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14123       };
14124     } catch (...) {
14125       {
14126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14127       };
14128     }
14129   }
14130   jresult = (unsigned long)result;
14131   return jresult;
14132 }
14133
14134
14135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14136   unsigned int jresult ;
14137   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14138   bool result;
14139
14140   arg1 = (Dali::Property::Map *)jarg1;
14141   {
14142     try {
14143       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14144     } catch (std::out_of_range& e) {
14145       {
14146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14147       };
14148     } catch (std::exception& e) {
14149       {
14150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14151       };
14152     } catch (...) {
14153       {
14154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14155       };
14156     }
14157   }
14158   jresult = result;
14159   return jresult;
14160 }
14161
14162
14163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14164   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14165   char *arg2 = (char *) 0 ;
14166   Dali::Property::Value *arg3 = 0 ;
14167
14168   arg1 = (Dali::Property::Map *)jarg1;
14169   arg2 = (char *)jarg2;
14170   arg3 = (Dali::Property::Value *)jarg3;
14171   if (!arg3) {
14172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14173     return ;
14174   }
14175   {
14176     try {
14177       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14178     } catch (std::out_of_range& e) {
14179       {
14180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14181       };
14182     } catch (std::exception& e) {
14183       {
14184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14185       };
14186     } catch (...) {
14187       {
14188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14189       };
14190     }
14191   }
14192 }
14193
14194
14195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14196   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14197   Dali::Property::Index arg2 ;
14198   Dali::Property::Value *arg3 = 0 ;
14199
14200   arg1 = (Dali::Property::Map *)jarg1;
14201   arg2 = (Dali::Property::Index)jarg2;
14202   arg3 = (Dali::Property::Value *)jarg3;
14203   if (!arg3) {
14204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14205     return ;
14206   }
14207   {
14208     try {
14209       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14210     } catch (std::out_of_range& e) {
14211       {
14212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14213       };
14214     } catch (std::exception& e) {
14215       {
14216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14217       };
14218     } catch (...) {
14219       {
14220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14221       };
14222     }
14223   }
14224 }
14225
14226
14227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14228   void * jresult ;
14229   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14230   char *arg2 = (char *) 0 ;
14231   Dali::Property::Value *arg3 = 0 ;
14232   Dali::Property::Map *result = 0 ;
14233
14234   arg1 = (Dali::Property::Map *)jarg1;
14235   arg2 = (char *)jarg2;
14236   arg3 = (Dali::Property::Value *)jarg3;
14237   if (!arg3) {
14238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14239     return 0;
14240   }
14241   {
14242     try {
14243       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14244     } catch (std::out_of_range& e) {
14245       {
14246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14247       };
14248     } catch (std::exception& e) {
14249       {
14250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14251       };
14252     } catch (...) {
14253       {
14254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14255       };
14256     }
14257   }
14258   jresult = (void *)result;
14259   return jresult;
14260 }
14261
14262
14263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14264   void * jresult ;
14265   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14266   Dali::Property::Index arg2 ;
14267   Dali::Property::Value *arg3 = 0 ;
14268   Dali::Property::Map *result = 0 ;
14269
14270   arg1 = (Dali::Property::Map *)jarg1;
14271   arg2 = (Dali::Property::Index)jarg2;
14272   arg3 = (Dali::Property::Value *)jarg3;
14273   if (!arg3) {
14274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14275     return 0;
14276   }
14277   {
14278     try {
14279       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14280     } catch (std::out_of_range& e) {
14281       {
14282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14283       };
14284     } catch (std::exception& e) {
14285       {
14286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14287       };
14288     } catch (...) {
14289       {
14290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14291       };
14292     }
14293   }
14294   jresult = (void *)result;
14295   return jresult;
14296 }
14297
14298
14299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14300   void * jresult ;
14301   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14302   Dali::Property::Map::SizeType arg2 ;
14303   Dali::Property::Value *result = 0 ;
14304
14305   arg1 = (Dali::Property::Map *)jarg1;
14306   arg2 = (Dali::Property::Map::SizeType)jarg2;
14307   {
14308     try {
14309       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14310     } catch (std::out_of_range& e) {
14311       {
14312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14313       };
14314     } catch (std::exception& e) {
14315       {
14316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14317       };
14318     } catch (...) {
14319       {
14320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14321       };
14322     }
14323   }
14324   jresult = (void *)result;
14325   return jresult;
14326 }
14327
14328
14329 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14330   char * jresult ;
14331   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14332   Dali::Property::Map::SizeType arg2 ;
14333   std::string *result = 0 ;
14334
14335   arg1 = (Dali::Property::Map *)jarg1;
14336   arg2 = (Dali::Property::Map::SizeType)jarg2;
14337   {
14338     try {
14339       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14340     } catch (std::out_of_range& e) {
14341       {
14342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14343       };
14344     } catch (std::exception& e) {
14345       {
14346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14347       };
14348     } catch (...) {
14349       {
14350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14351       };
14352     }
14353   }
14354   jresult = SWIG_csharp_string_callback(result->c_str());
14355   return jresult;
14356 }
14357
14358
14359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14360   void * jresult ;
14361   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14362   Dali::Property::Map::SizeType arg2 ;
14363   SwigValueWrapper< Dali::Property::Key > result;
14364
14365   arg1 = (Dali::Property::Map *)jarg1;
14366   arg2 = (Dali::Property::Map::SizeType)jarg2;
14367   {
14368     try {
14369       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14370     } catch (std::out_of_range& e) {
14371       {
14372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14373       };
14374     } catch (std::exception& e) {
14375       {
14376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14377       };
14378     } catch (...) {
14379       {
14380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14381       };
14382     }
14383   }
14384   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14385   return jresult;
14386 }
14387
14388
14389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14390   void * jresult ;
14391   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14392   Dali::Property::Map::SizeType arg2 ;
14393   StringValuePair *result = 0 ;
14394
14395   arg1 = (Dali::Property::Map *)jarg1;
14396   arg2 = (Dali::Property::Map::SizeType)jarg2;
14397   {
14398     try {
14399       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14400     } catch (std::out_of_range& e) {
14401       {
14402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14403       };
14404     } catch (std::exception& e) {
14405       {
14406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14407       };
14408     } catch (...) {
14409       {
14410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14411       };
14412     }
14413   }
14414   jresult = (void *)result;
14415   return jresult;
14416 }
14417
14418
14419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14420   void * jresult ;
14421   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14422   char *arg2 = (char *) 0 ;
14423   Dali::Property::Value *result = 0 ;
14424
14425   arg1 = (Dali::Property::Map *)jarg1;
14426   arg2 = (char *)jarg2;
14427   {
14428     try {
14429       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14430     } catch (std::out_of_range& e) {
14431       {
14432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14433       };
14434     } catch (std::exception& e) {
14435       {
14436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14437       };
14438     } catch (...) {
14439       {
14440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14441       };
14442     }
14443   }
14444   jresult = (void *)result;
14445   return jresult;
14446 }
14447
14448
14449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14450   void * jresult ;
14451   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14452   Dali::Property::Index arg2 ;
14453   Dali::Property::Value *result = 0 ;
14454
14455   arg1 = (Dali::Property::Map *)jarg1;
14456   arg2 = (Dali::Property::Index)jarg2;
14457   {
14458     try {
14459       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14460     } catch (std::out_of_range& e) {
14461       {
14462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14463       };
14464     } catch (std::exception& e) {
14465       {
14466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14467       };
14468     } catch (...) {
14469       {
14470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14471       };
14472     }
14473   }
14474   jresult = (void *)result;
14475   return jresult;
14476 }
14477
14478
14479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14480   void * jresult ;
14481   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14482   Dali::Property::Index arg2 ;
14483   std::string *arg3 = 0 ;
14484   Dali::Property::Value *result = 0 ;
14485
14486   arg1 = (Dali::Property::Map *)jarg1;
14487   arg2 = (Dali::Property::Index)jarg2;
14488   if (!jarg3) {
14489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14490     return 0;
14491   }
14492   std::string arg3_str(jarg3);
14493   arg3 = &arg3_str;
14494   {
14495     try {
14496       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14497     } catch (std::out_of_range& e) {
14498       {
14499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14500       };
14501     } catch (std::exception& e) {
14502       {
14503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14504       };
14505     } catch (...) {
14506       {
14507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14508       };
14509     }
14510   }
14511   jresult = (void *)result;
14512
14513   //argout typemap for const std::string&
14514
14515   return jresult;
14516 }
14517
14518
14519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14520   void * jresult ;
14521   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14522   std::string *arg2 = 0 ;
14523   Dali::Property::Type arg3 ;
14524   Dali::Property::Value *result = 0 ;
14525
14526   arg1 = (Dali::Property::Map *)jarg1;
14527   if (!jarg2) {
14528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14529     return 0;
14530   }
14531   std::string arg2_str(jarg2);
14532   arg2 = &arg2_str;
14533   arg3 = (Dali::Property::Type)jarg3;
14534   {
14535     try {
14536       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14537     } catch (std::out_of_range& e) {
14538       {
14539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14540       };
14541     } catch (std::exception& e) {
14542       {
14543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14544       };
14545     } catch (...) {
14546       {
14547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14548       };
14549     }
14550   }
14551   jresult = (void *)result;
14552
14553   //argout typemap for const std::string&
14554
14555   return jresult;
14556 }
14557
14558
14559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14560   void * jresult ;
14561   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14562   Dali::Property::Index arg2 ;
14563   Dali::Property::Type arg3 ;
14564   Dali::Property::Value *result = 0 ;
14565
14566   arg1 = (Dali::Property::Map *)jarg1;
14567   arg2 = (Dali::Property::Index)jarg2;
14568   arg3 = (Dali::Property::Type)jarg3;
14569   {
14570     try {
14571       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14572     } catch (std::out_of_range& e) {
14573       {
14574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14575       };
14576     } catch (std::exception& e) {
14577       {
14578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14579       };
14580     } catch (...) {
14581       {
14582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14583       };
14584     }
14585   }
14586   jresult = (void *)result;
14587   return jresult;
14588 }
14589
14590
14591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14592   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14593
14594   arg1 = (Dali::Property::Map *)jarg1;
14595   {
14596     try {
14597       (arg1)->Clear();
14598     } catch (std::out_of_range& e) {
14599       {
14600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14601       };
14602     } catch (std::exception& e) {
14603       {
14604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14605       };
14606     } catch (...) {
14607       {
14608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14609       };
14610     }
14611   }
14612 }
14613
14614
14615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14616   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14617   Dali::Property::Map *arg2 = 0 ;
14618
14619   arg1 = (Dali::Property::Map *)jarg1;
14620   arg2 = (Dali::Property::Map *)jarg2;
14621   if (!arg2) {
14622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14623     return ;
14624   }
14625   {
14626     try {
14627       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14628     } catch (std::out_of_range& e) {
14629       {
14630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14631       };
14632     } catch (std::exception& e) {
14633       {
14634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14635       };
14636     } catch (...) {
14637       {
14638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14639       };
14640     }
14641   }
14642 }
14643
14644
14645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14646   void * jresult ;
14647   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14648   std::string *arg2 = 0 ;
14649   Dali::Property::Value *result = 0 ;
14650
14651   arg1 = (Dali::Property::Map *)jarg1;
14652   if (!jarg2) {
14653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14654     return 0;
14655   }
14656   std::string arg2_str(jarg2);
14657   arg2 = &arg2_str;
14658   {
14659     try {
14660       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14661     } catch (std::out_of_range& e) {
14662       {
14663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14664       };
14665     } catch (std::exception& e) {
14666       {
14667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14668       };
14669     } catch (...) {
14670       {
14671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14672       };
14673     }
14674   }
14675   jresult = (void *)result;
14676
14677   //argout typemap for const std::string&
14678
14679   return jresult;
14680 }
14681
14682
14683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14684   void * jresult ;
14685   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14686   Dali::Property::Index arg2 ;
14687   Dali::Property::Value *result = 0 ;
14688
14689   arg1 = (Dali::Property::Map *)jarg1;
14690   arg2 = (Dali::Property::Index)jarg2;
14691   {
14692     try {
14693       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14694     } catch (std::out_of_range& e) {
14695       {
14696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14697       };
14698     } catch (std::exception& e) {
14699       {
14700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14701       };
14702     } catch (...) {
14703       {
14704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14705       };
14706     }
14707   }
14708   jresult = (void *)result;
14709   return jresult;
14710 }
14711
14712
14713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14714   void * jresult ;
14715   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14716   Dali::Property::Map *arg2 = 0 ;
14717   Dali::Property::Map *result = 0 ;
14718
14719   arg1 = (Dali::Property::Map *)jarg1;
14720   arg2 = (Dali::Property::Map *)jarg2;
14721   if (!arg2) {
14722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14723     return 0;
14724   }
14725   {
14726     try {
14727       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14728     } catch (std::out_of_range& e) {
14729       {
14730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14731       };
14732     } catch (std::exception& e) {
14733       {
14734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14735       };
14736     } catch (...) {
14737       {
14738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14739       };
14740     }
14741   }
14742   jresult = (void *)result;
14743   return jresult;
14744 }
14745
14746
14747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14748   void * jresult ;
14749   Dali::Property::Value *result = 0 ;
14750
14751   {
14752     try {
14753       result = (Dali::Property::Value *)new Dali::Property::Value();
14754     } catch (std::out_of_range& e) {
14755       {
14756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14757       };
14758     } catch (std::exception& e) {
14759       {
14760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14761       };
14762     } catch (...) {
14763       {
14764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14765       };
14766     }
14767   }
14768   jresult = (void *)result;
14769   return jresult;
14770 }
14771
14772
14773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14774   void * jresult ;
14775   bool arg1 ;
14776   Dali::Property::Value *result = 0 ;
14777
14778   arg1 = jarg1 ? true : false;
14779   {
14780     try {
14781       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14782     } catch (std::out_of_range& e) {
14783       {
14784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14785       };
14786     } catch (std::exception& e) {
14787       {
14788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14789       };
14790     } catch (...) {
14791       {
14792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14793       };
14794     }
14795   }
14796   jresult = (void *)result;
14797   return jresult;
14798 }
14799
14800
14801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14802   void * jresult ;
14803   int arg1 ;
14804   Dali::Property::Value *result = 0 ;
14805
14806   arg1 = (int)jarg1;
14807   {
14808     try {
14809       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14810     } catch (std::out_of_range& e) {
14811       {
14812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14813       };
14814     } catch (std::exception& e) {
14815       {
14816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14817       };
14818     } catch (...) {
14819       {
14820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14821       };
14822     }
14823   }
14824   jresult = (void *)result;
14825   return jresult;
14826 }
14827
14828
14829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14830   void * jresult ;
14831   float arg1 ;
14832   Dali::Property::Value *result = 0 ;
14833
14834   arg1 = (float)jarg1;
14835   {
14836     try {
14837       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14838     } catch (std::out_of_range& e) {
14839       {
14840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14841       };
14842     } catch (std::exception& e) {
14843       {
14844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14845       };
14846     } catch (...) {
14847       {
14848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14849       };
14850     }
14851   }
14852   jresult = (void *)result;
14853   return jresult;
14854 }
14855
14856
14857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14858   void * jresult ;
14859   Dali::Vector2 *arg1 = 0 ;
14860   Dali::Property::Value *result = 0 ;
14861
14862   arg1 = (Dali::Vector2 *)jarg1;
14863   if (!arg1) {
14864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14865     return 0;
14866   }
14867   {
14868     try {
14869       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14870     } catch (std::out_of_range& e) {
14871       {
14872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14873       };
14874     } catch (std::exception& e) {
14875       {
14876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14877       };
14878     } catch (...) {
14879       {
14880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14881       };
14882     }
14883   }
14884   jresult = (void *)result;
14885   return jresult;
14886 }
14887
14888
14889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14890   void * jresult ;
14891   Dali::Vector3 *arg1 = 0 ;
14892   Dali::Property::Value *result = 0 ;
14893
14894   arg1 = (Dali::Vector3 *)jarg1;
14895   if (!arg1) {
14896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14897     return 0;
14898   }
14899   {
14900     try {
14901       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14902     } catch (std::out_of_range& e) {
14903       {
14904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14905       };
14906     } catch (std::exception& e) {
14907       {
14908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14909       };
14910     } catch (...) {
14911       {
14912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14913       };
14914     }
14915   }
14916   jresult = (void *)result;
14917   return jresult;
14918 }
14919
14920
14921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14922   void * jresult ;
14923   Dali::Vector4 *arg1 = 0 ;
14924   Dali::Property::Value *result = 0 ;
14925
14926   arg1 = (Dali::Vector4 *)jarg1;
14927   if (!arg1) {
14928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14929     return 0;
14930   }
14931   {
14932     try {
14933       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14934     } catch (std::out_of_range& e) {
14935       {
14936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14937       };
14938     } catch (std::exception& e) {
14939       {
14940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14941       };
14942     } catch (...) {
14943       {
14944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14945       };
14946     }
14947   }
14948   jresult = (void *)result;
14949   return jresult;
14950 }
14951
14952
14953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14954   void * jresult ;
14955   Dali::Matrix3 *arg1 = 0 ;
14956   Dali::Property::Value *result = 0 ;
14957
14958   arg1 = (Dali::Matrix3 *)jarg1;
14959   if (!arg1) {
14960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14961     return 0;
14962   }
14963   {
14964     try {
14965       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14966     } catch (std::out_of_range& e) {
14967       {
14968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14969       };
14970     } catch (std::exception& e) {
14971       {
14972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14973       };
14974     } catch (...) {
14975       {
14976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14977       };
14978     }
14979   }
14980   jresult = (void *)result;
14981   return jresult;
14982 }
14983
14984
14985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
14986   void * jresult ;
14987   Dali::Matrix *arg1 = 0 ;
14988   Dali::Property::Value *result = 0 ;
14989
14990   arg1 = (Dali::Matrix *)jarg1;
14991   if (!arg1) {
14992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
14993     return 0;
14994   }
14995   {
14996     try {
14997       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
14998     } catch (std::out_of_range& e) {
14999       {
15000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15001       };
15002     } catch (std::exception& e) {
15003       {
15004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15005       };
15006     } catch (...) {
15007       {
15008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15009       };
15010     }
15011   }
15012   jresult = (void *)result;
15013   return jresult;
15014 }
15015
15016
15017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15018   void * jresult ;
15019   Dali::Rect< int > *arg1 = 0 ;
15020   Dali::Property::Value *result = 0 ;
15021
15022   arg1 = (Dali::Rect< int > *)jarg1;
15023   if (!arg1) {
15024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15025     return 0;
15026   }
15027   {
15028     try {
15029       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15030     } catch (std::out_of_range& e) {
15031       {
15032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15033       };
15034     } catch (std::exception& e) {
15035       {
15036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15037       };
15038     } catch (...) {
15039       {
15040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15041       };
15042     }
15043   }
15044   jresult = (void *)result;
15045   return jresult;
15046 }
15047
15048
15049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15050   void * jresult ;
15051   Dali::AngleAxis *arg1 = 0 ;
15052   Dali::Property::Value *result = 0 ;
15053
15054   arg1 = (Dali::AngleAxis *)jarg1;
15055   if (!arg1) {
15056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15057     return 0;
15058   }
15059   {
15060     try {
15061       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15062     } catch (std::out_of_range& e) {
15063       {
15064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15065       };
15066     } catch (std::exception& e) {
15067       {
15068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15069       };
15070     } catch (...) {
15071       {
15072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15073       };
15074     }
15075   }
15076   jresult = (void *)result;
15077   return jresult;
15078 }
15079
15080
15081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15082   void * jresult ;
15083   Dali::Quaternion *arg1 = 0 ;
15084   Dali::Property::Value *result = 0 ;
15085
15086   arg1 = (Dali::Quaternion *)jarg1;
15087   if (!arg1) {
15088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15089     return 0;
15090   }
15091   {
15092     try {
15093       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15094     } catch (std::out_of_range& e) {
15095       {
15096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15097       };
15098     } catch (std::exception& e) {
15099       {
15100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15101       };
15102     } catch (...) {
15103       {
15104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15105       };
15106     }
15107   }
15108   jresult = (void *)result;
15109   return jresult;
15110 }
15111
15112
15113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15114   void * jresult ;
15115   std::string *arg1 = 0 ;
15116   Dali::Property::Value *result = 0 ;
15117
15118   if (!jarg1) {
15119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15120     return 0;
15121   }
15122   std::string arg1_str(jarg1);
15123   arg1 = &arg1_str;
15124   {
15125     try {
15126       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15127     } catch (std::out_of_range& e) {
15128       {
15129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15130       };
15131     } catch (std::exception& e) {
15132       {
15133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15134       };
15135     } catch (...) {
15136       {
15137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15138       };
15139     }
15140   }
15141   jresult = (void *)result;
15142
15143   //argout typemap for const std::string&
15144
15145   return jresult;
15146 }
15147
15148
15149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15150   void * jresult ;
15151   Dali::Property::Array *arg1 = 0 ;
15152   Dali::Property::Value *result = 0 ;
15153
15154   arg1 = (Dali::Property::Array *)jarg1;
15155   if (!arg1) {
15156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15157     return 0;
15158   }
15159   {
15160     try {
15161       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15162     } catch (std::out_of_range& e) {
15163       {
15164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15165       };
15166     } catch (std::exception& e) {
15167       {
15168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15169       };
15170     } catch (...) {
15171       {
15172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15173       };
15174     }
15175   }
15176   jresult = (void *)result;
15177   return jresult;
15178 }
15179
15180
15181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15182   void * jresult ;
15183   Dali::Property::Map *arg1 = 0 ;
15184   Dali::Property::Value *result = 0 ;
15185
15186   arg1 = (Dali::Property::Map *)jarg1;
15187   if (!arg1) {
15188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15189     return 0;
15190   }
15191   {
15192     try {
15193       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15194     } catch (std::out_of_range& e) {
15195       {
15196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15197       };
15198     } catch (std::exception& e) {
15199       {
15200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15201       };
15202     } catch (...) {
15203       {
15204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15205       };
15206     }
15207   }
15208   jresult = (void *)result;
15209   return jresult;
15210 }
15211
15212
15213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15214   void * jresult ;
15215   Dali::Property::Type arg1 ;
15216   Dali::Property::Value *result = 0 ;
15217
15218   arg1 = (Dali::Property::Type)jarg1;
15219   {
15220     try {
15221       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15222     } catch (std::out_of_range& e) {
15223       {
15224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15225       };
15226     } catch (std::exception& e) {
15227       {
15228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15229       };
15230     } catch (...) {
15231       {
15232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15233       };
15234     }
15235   }
15236   jresult = (void *)result;
15237   return jresult;
15238 }
15239
15240
15241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15242   void * jresult ;
15243   Dali::Property::Value *arg1 = 0 ;
15244   Dali::Property::Value *result = 0 ;
15245
15246   arg1 = (Dali::Property::Value *)jarg1;
15247   if (!arg1) {
15248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15249     return 0;
15250   }
15251   {
15252     try {
15253       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15254     } catch (std::out_of_range& e) {
15255       {
15256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15257       };
15258     } catch (std::exception& e) {
15259       {
15260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15261       };
15262     } catch (...) {
15263       {
15264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15265       };
15266     }
15267   }
15268   jresult = (void *)result;
15269   return jresult;
15270 }
15271
15272
15273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15274   void * jresult ;
15275   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15276   Dali::Property::Value *arg2 = 0 ;
15277   Dali::Property::Value *result = 0 ;
15278
15279   arg1 = (Dali::Property::Value *)jarg1;
15280   arg2 = (Dali::Property::Value *)jarg2;
15281   if (!arg2) {
15282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15283     return 0;
15284   }
15285   {
15286     try {
15287       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15288     } catch (std::out_of_range& e) {
15289       {
15290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15291       };
15292     } catch (std::exception& e) {
15293       {
15294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15295       };
15296     } catch (...) {
15297       {
15298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15299       };
15300     }
15301   }
15302   jresult = (void *)result;
15303   return jresult;
15304 }
15305
15306
15307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15308   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15309
15310   arg1 = (Dali::Property::Value *)jarg1;
15311   {
15312     try {
15313       delete arg1;
15314     } catch (std::out_of_range& e) {
15315       {
15316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15317       };
15318     } catch (std::exception& e) {
15319       {
15320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15321       };
15322     } catch (...) {
15323       {
15324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15325       };
15326     }
15327   }
15328 }
15329
15330
15331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15332   int jresult ;
15333   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15334   Dali::Property::Type result;
15335
15336   arg1 = (Dali::Property::Value *)jarg1;
15337   {
15338     try {
15339       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15340     } catch (std::out_of_range& e) {
15341       {
15342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15343       };
15344     } catch (std::exception& e) {
15345       {
15346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15347       };
15348     } catch (...) {
15349       {
15350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15351       };
15352     }
15353   }
15354   jresult = (int)result;
15355   return jresult;
15356 }
15357
15358
15359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15360   unsigned int jresult ;
15361   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15362   bool *arg2 = 0 ;
15363   bool result;
15364
15365   arg1 = (Dali::Property::Value *)jarg1;
15366   arg2 = (bool *)jarg2;
15367   {
15368     try {
15369       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15370     } catch (std::out_of_range& e) {
15371       {
15372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15373       };
15374     } catch (std::exception& e) {
15375       {
15376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15377       };
15378     } catch (...) {
15379       {
15380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15381       };
15382     }
15383   }
15384   jresult = result;
15385   return jresult;
15386 }
15387
15388
15389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15390   unsigned int jresult ;
15391   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15392   float *arg2 = 0 ;
15393   bool result;
15394
15395   arg1 = (Dali::Property::Value *)jarg1;
15396   arg2 = (float *)jarg2;
15397   {
15398     try {
15399       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15400     } catch (std::out_of_range& e) {
15401       {
15402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15403       };
15404     } catch (std::exception& e) {
15405       {
15406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15407       };
15408     } catch (...) {
15409       {
15410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15411       };
15412     }
15413   }
15414   jresult = result;
15415   return jresult;
15416 }
15417
15418
15419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15420   unsigned int jresult ;
15421   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15422   int *arg2 = 0 ;
15423   bool result;
15424
15425   arg1 = (Dali::Property::Value *)jarg1;
15426   arg2 = (int *)jarg2;
15427   {
15428     try {
15429       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15430     } catch (std::out_of_range& e) {
15431       {
15432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15433       };
15434     } catch (std::exception& e) {
15435       {
15436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15437       };
15438     } catch (...) {
15439       {
15440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15441       };
15442     }
15443   }
15444   jresult = result;
15445   return jresult;
15446 }
15447
15448
15449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15450   unsigned int jresult ;
15451   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15452   Dali::Rect< int > *arg2 = 0 ;
15453   bool result;
15454
15455   arg1 = (Dali::Property::Value *)jarg1;
15456   arg2 = (Dali::Rect< int > *)jarg2;
15457   if (!arg2) {
15458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15459     return 0;
15460   }
15461   {
15462     try {
15463       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15464     } catch (std::out_of_range& e) {
15465       {
15466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15467       };
15468     } catch (std::exception& e) {
15469       {
15470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15471       };
15472     } catch (...) {
15473       {
15474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15475       };
15476     }
15477   }
15478   jresult = result;
15479   return jresult;
15480 }
15481
15482
15483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15484   unsigned int jresult ;
15485   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15486   Dali::Vector2 *arg2 = 0 ;
15487   bool result;
15488
15489   arg1 = (Dali::Property::Value *)jarg1;
15490   arg2 = (Dali::Vector2 *)jarg2;
15491   if (!arg2) {
15492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15493     return 0;
15494   }
15495   {
15496     try {
15497       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15498     } catch (std::out_of_range& e) {
15499       {
15500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15501       };
15502     } catch (std::exception& e) {
15503       {
15504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15505       };
15506     } catch (...) {
15507       {
15508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15509       };
15510     }
15511   }
15512   jresult = result;
15513   return jresult;
15514 }
15515
15516
15517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15518   unsigned int jresult ;
15519   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15520   Dali::Vector3 *arg2 = 0 ;
15521   bool result;
15522
15523   arg1 = (Dali::Property::Value *)jarg1;
15524   arg2 = (Dali::Vector3 *)jarg2;
15525   if (!arg2) {
15526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15527     return 0;
15528   }
15529   {
15530     try {
15531       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15532     } catch (std::out_of_range& e) {
15533       {
15534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15535       };
15536     } catch (std::exception& e) {
15537       {
15538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15539       };
15540     } catch (...) {
15541       {
15542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15543       };
15544     }
15545   }
15546   jresult = result;
15547   return jresult;
15548 }
15549
15550
15551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15552   unsigned int jresult ;
15553   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15554   Dali::Vector4 *arg2 = 0 ;
15555   bool result;
15556
15557   arg1 = (Dali::Property::Value *)jarg1;
15558   arg2 = (Dali::Vector4 *)jarg2;
15559   if (!arg2) {
15560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15561     return 0;
15562   }
15563   {
15564     try {
15565       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15566     } catch (std::out_of_range& e) {
15567       {
15568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15569       };
15570     } catch (std::exception& e) {
15571       {
15572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15573       };
15574     } catch (...) {
15575       {
15576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15577       };
15578     }
15579   }
15580   jresult = result;
15581   return jresult;
15582 }
15583
15584
15585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15586   unsigned int jresult ;
15587   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15588   Dali::Matrix3 *arg2 = 0 ;
15589   bool result;
15590
15591   arg1 = (Dali::Property::Value *)jarg1;
15592   arg2 = (Dali::Matrix3 *)jarg2;
15593   if (!arg2) {
15594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15595     return 0;
15596   }
15597   {
15598     try {
15599       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15600     } catch (std::out_of_range& e) {
15601       {
15602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15603       };
15604     } catch (std::exception& e) {
15605       {
15606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15607       };
15608     } catch (...) {
15609       {
15610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15611       };
15612     }
15613   }
15614   jresult = result;
15615   return jresult;
15616 }
15617
15618
15619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15620   unsigned int jresult ;
15621   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15622   Dali::Matrix *arg2 = 0 ;
15623   bool result;
15624
15625   arg1 = (Dali::Property::Value *)jarg1;
15626   arg2 = (Dali::Matrix *)jarg2;
15627   if (!arg2) {
15628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15629     return 0;
15630   }
15631   {
15632     try {
15633       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15634     } catch (std::out_of_range& e) {
15635       {
15636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15637       };
15638     } catch (std::exception& e) {
15639       {
15640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15641       };
15642     } catch (...) {
15643       {
15644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15645       };
15646     }
15647   }
15648   jresult = result;
15649   return jresult;
15650 }
15651
15652
15653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15654   unsigned int jresult ;
15655   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15656   Dali::AngleAxis *arg2 = 0 ;
15657   bool result;
15658
15659   arg1 = (Dali::Property::Value *)jarg1;
15660   arg2 = (Dali::AngleAxis *)jarg2;
15661   if (!arg2) {
15662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15663     return 0;
15664   }
15665   {
15666     try {
15667       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15668     } catch (std::out_of_range& e) {
15669       {
15670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15671       };
15672     } catch (std::exception& e) {
15673       {
15674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15675       };
15676     } catch (...) {
15677       {
15678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15679       };
15680     }
15681   }
15682   jresult = result;
15683   return jresult;
15684 }
15685
15686
15687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15688   unsigned int jresult ;
15689   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15690   Dali::Quaternion *arg2 = 0 ;
15691   bool result;
15692
15693   arg1 = (Dali::Property::Value *)jarg1;
15694   arg2 = (Dali::Quaternion *)jarg2;
15695   if (!arg2) {
15696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15697     return 0;
15698   }
15699   {
15700     try {
15701       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15702     } catch (std::out_of_range& e) {
15703       {
15704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15705       };
15706     } catch (std::exception& e) {
15707       {
15708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15709       };
15710     } catch (...) {
15711       {
15712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15713       };
15714     }
15715   }
15716   jresult = result;
15717   return jresult;
15718 }
15719
15720
15721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15722   unsigned int jresult ;
15723   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15724   std::string *arg2 = 0 ;
15725   bool result;
15726
15727   arg1 = (Dali::Property::Value *)jarg1;
15728
15729   //typemap in
15730   std::string temp;
15731   arg2 = &temp;
15732
15733   {
15734     try {
15735       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15736     } catch (std::out_of_range& e) {
15737       {
15738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15739       };
15740     } catch (std::exception& e) {
15741       {
15742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15743       };
15744     } catch (...) {
15745       {
15746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15747       };
15748     }
15749   }
15750   jresult = result;
15751
15752   //Typemap argout in c++ file.
15753   //This will convert c++ string to c# string
15754   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15755
15756   return jresult;
15757 }
15758
15759
15760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15761   unsigned int jresult ;
15762   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15763   Dali::Property::Array *arg2 = 0 ;
15764   bool result;
15765
15766   arg1 = (Dali::Property::Value *)jarg1;
15767   arg2 = (Dali::Property::Array *)jarg2;
15768   if (!arg2) {
15769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15770     return 0;
15771   }
15772   {
15773     try {
15774       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15775     } catch (std::out_of_range& e) {
15776       {
15777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15778       };
15779     } catch (std::exception& e) {
15780       {
15781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15782       };
15783     } catch (...) {
15784       {
15785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15786       };
15787     }
15788   }
15789   jresult = result;
15790   return jresult;
15791 }
15792
15793
15794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15795   unsigned int jresult ;
15796   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15797   Dali::Property::Map *arg2 = 0 ;
15798   bool result;
15799
15800   arg1 = (Dali::Property::Value *)jarg1;
15801   arg2 = (Dali::Property::Map *)jarg2;
15802   if (!arg2) {
15803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15804     return 0;
15805   }
15806   {
15807     try {
15808       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15809     } catch (std::out_of_range& e) {
15810       {
15811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15812       };
15813     } catch (std::exception& e) {
15814       {
15815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15816       };
15817     } catch (...) {
15818       {
15819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15820       };
15821     }
15822   }
15823   jresult = result;
15824   return jresult;
15825 }
15826
15827
15828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15829   void * jresult ;
15830   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15831   Dali::Property::Array *result = 0 ;
15832
15833   arg1 = (Dali::Property::Value *)jarg1;
15834   {
15835     try {
15836       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15837     } catch (std::out_of_range& e) {
15838       {
15839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15840       };
15841     } catch (std::exception& e) {
15842       {
15843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15844       };
15845     } catch (...) {
15846       {
15847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15848       };
15849     }
15850   }
15851   jresult = (void *)result;
15852   return jresult;
15853 }
15854
15855
15856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15857   void * jresult ;
15858   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15859   Dali::Property::Map *result = 0 ;
15860
15861   arg1 = (Dali::Property::Value *)jarg1;
15862   {
15863     try {
15864       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15865     } catch (std::out_of_range& e) {
15866       {
15867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15868       };
15869     } catch (std::exception& e) {
15870       {
15871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15872       };
15873     } catch (...) {
15874       {
15875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15876       };
15877     }
15878   }
15879   jresult = (void *)result;
15880   return jresult;
15881 }
15882
15883
15884 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15885   char * jresult ;
15886   Dali::Property::Type arg1 ;
15887   char *result = 0 ;
15888
15889   arg1 = (Dali::Property::Type)jarg1;
15890   {
15891     try {
15892       result = (char *)Dali::PropertyTypes::GetName(arg1);
15893     } catch (std::out_of_range& e) {
15894       {
15895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15896       };
15897     } catch (std::exception& e) {
15898       {
15899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15900       };
15901     } catch (...) {
15902       {
15903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15904       };
15905     }
15906   }
15907   jresult = SWIG_csharp_string_callback((const char *)result);
15908   return jresult;
15909 }
15910
15911
15912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15913   unsigned int jresult ;
15914   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15915   std::string *arg2 = 0 ;
15916   Dali::Property::Map *arg3 = 0 ;
15917   bool result;
15918
15919   arg1 = (Dali::BaseObject *)jarg1;
15920   if (!jarg2) {
15921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15922     return 0;
15923   }
15924   std::string arg2_str(jarg2);
15925   arg2 = &arg2_str;
15926   arg3 = (Dali::Property::Map *)jarg3;
15927   if (!arg3) {
15928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15929     return 0;
15930   }
15931   {
15932     try {
15933       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15934     } catch (std::out_of_range& e) {
15935       {
15936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15937       };
15938     } catch (std::exception& e) {
15939       {
15940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15941       };
15942     } catch (...) {
15943       {
15944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15945       };
15946     }
15947   }
15948   jresult = result;
15949
15950   //argout typemap for const std::string&
15951
15952   return jresult;
15953 }
15954
15955
15956 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15957   char * jresult ;
15958   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15959   std::string *result = 0 ;
15960
15961   arg1 = (Dali::BaseObject *)jarg1;
15962   {
15963     try {
15964       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15965     } catch (std::out_of_range& e) {
15966       {
15967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15968       };
15969     } catch (std::exception& e) {
15970       {
15971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15972       };
15973     } catch (...) {
15974       {
15975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15976       };
15977     }
15978   }
15979   jresult = SWIG_csharp_string_callback(result->c_str());
15980   return jresult;
15981 }
15982
15983
15984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
15985   unsigned int jresult ;
15986   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15987   Dali::TypeInfo *arg2 = 0 ;
15988   bool result;
15989
15990   arg1 = (Dali::BaseObject *)jarg1;
15991   arg2 = (Dali::TypeInfo *)jarg2;
15992   if (!arg2) {
15993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
15994     return 0;
15995   }
15996   {
15997     try {
15998       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
15999     } catch (std::out_of_range& e) {
16000       {
16001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16002       };
16003     } catch (std::exception& e) {
16004       {
16005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16006       };
16007     } catch (...) {
16008       {
16009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16010       };
16011     }
16012   }
16013   jresult = result;
16014   return jresult;
16015 }
16016
16017
16018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16019   unsigned int jresult ;
16020   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16021   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16022   std::string *arg3 = 0 ;
16023   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16024   bool result;
16025
16026   arg1 = (Dali::BaseObject *)jarg1;
16027   arg2 = (ConnectionTrackerInterface *)jarg2;
16028   if (!jarg3) {
16029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16030     return 0;
16031   }
16032   std::string arg3_str(jarg3);
16033   arg3 = &arg3_str;
16034   arg4 = (FunctorDelegate *)jarg4;
16035   {
16036     try {
16037       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16038     } catch (std::out_of_range& e) {
16039       {
16040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16041       };
16042     } catch (std::exception& e) {
16043       {
16044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16045       };
16046     } catch (...) {
16047       {
16048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16049       };
16050     }
16051   }
16052   jresult = result;
16053
16054   //argout typemap for const std::string&
16055
16056   return jresult;
16057 }
16058
16059
16060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16061   void * jresult ;
16062   Dali::BaseHandle *arg1 = 0 ;
16063   Dali::BaseObject *result = 0 ;
16064
16065   arg1 = (Dali::BaseHandle *)jarg1;
16066   if (!arg1) {
16067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16068     return 0;
16069   }
16070   {
16071     try {
16072       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16073     } catch (std::out_of_range& e) {
16074       {
16075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16076       };
16077     } catch (std::exception& e) {
16078       {
16079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16080       };
16081     } catch (...) {
16082       {
16083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16084       };
16085     }
16086   }
16087   jresult = (void *)result;
16088   return jresult;
16089 }
16090
16091
16092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16093   void * jresult ;
16094   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16095   Dali::BaseHandle *result = 0 ;
16096
16097   arg1 = (Dali::BaseObject *)jarg1;
16098   {
16099     try {
16100       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16101     } catch (std::out_of_range& e) {
16102       {
16103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16104       };
16105     } catch (std::exception& e) {
16106       {
16107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16108       };
16109     } catch (...) {
16110       {
16111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16112       };
16113     }
16114   }
16115   jresult = (void *)result;
16116   return jresult;
16117 }
16118
16119
16120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16121   void * jresult ;
16122   Dali::BaseHandle *result = 0 ;
16123
16124   {
16125     try {
16126       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16127     } catch (std::out_of_range& e) {
16128       {
16129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16130       };
16131     } catch (std::exception& e) {
16132       {
16133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16134       };
16135     } catch (...) {
16136       {
16137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16138       };
16139     }
16140   }
16141   jresult = (void *)result;
16142   return jresult;
16143 }
16144
16145
16146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16147   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16148
16149   arg1 = (Dali::BaseHandle *)jarg1;
16150   {
16151     try {
16152       delete arg1;
16153     } catch (std::out_of_range& e) {
16154       {
16155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16156       };
16157     } catch (std::exception& e) {
16158       {
16159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16160       };
16161     } catch (...) {
16162       {
16163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16164       };
16165     }
16166   }
16167 }
16168
16169
16170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16171   void * jresult ;
16172   Dali::BaseHandle *arg1 = 0 ;
16173   Dali::BaseHandle *result = 0 ;
16174
16175   arg1 = (Dali::BaseHandle *)jarg1;
16176   if (!arg1) {
16177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16178     return 0;
16179   }
16180   {
16181     try {
16182       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16183     } catch (std::out_of_range& e) {
16184       {
16185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16186       };
16187     } catch (std::exception& e) {
16188       {
16189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16190       };
16191     } catch (...) {
16192       {
16193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16194       };
16195     }
16196   }
16197   jresult = (void *)result;
16198   return jresult;
16199 }
16200
16201
16202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16203   void * jresult ;
16204   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16205   Dali::BaseHandle *arg2 = 0 ;
16206   Dali::BaseHandle *result = 0 ;
16207
16208   arg1 = (Dali::BaseHandle *)jarg1;
16209   arg2 = (Dali::BaseHandle *)jarg2;
16210   if (!arg2) {
16211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16212     return 0;
16213   }
16214   {
16215     try {
16216       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16217     } catch (std::out_of_range& e) {
16218       {
16219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16220       };
16221     } catch (std::exception& e) {
16222       {
16223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16224       };
16225     } catch (...) {
16226       {
16227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16228       };
16229     }
16230   }
16231   jresult = (void *)result;
16232   return jresult;
16233 }
16234
16235
16236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16237   unsigned int jresult ;
16238   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16239   std::string *arg2 = 0 ;
16240   Dali::Property::Map *arg3 = 0 ;
16241   bool result;
16242
16243   arg1 = (Dali::BaseHandle *)jarg1;
16244   if (!jarg2) {
16245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16246     return 0;
16247   }
16248   std::string arg2_str(jarg2);
16249   arg2 = &arg2_str;
16250   arg3 = (Dali::Property::Map *)jarg3;
16251   if (!arg3) {
16252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16253     return 0;
16254   }
16255   {
16256     try {
16257       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16258     } catch (std::out_of_range& e) {
16259       {
16260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16261       };
16262     } catch (std::exception& e) {
16263       {
16264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16265       };
16266     } catch (...) {
16267       {
16268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16269       };
16270     }
16271   }
16272   jresult = result;
16273
16274   //argout typemap for const std::string&
16275
16276   return jresult;
16277 }
16278
16279
16280 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16281   char * jresult ;
16282   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16283   std::string *result = 0 ;
16284
16285   arg1 = (Dali::BaseHandle *)jarg1;
16286   {
16287     try {
16288       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16289     } catch (std::out_of_range& e) {
16290       {
16291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16292       };
16293     } catch (std::exception& e) {
16294       {
16295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16296       };
16297     } catch (...) {
16298       {
16299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16300       };
16301     }
16302   }
16303   jresult = SWIG_csharp_string_callback(result->c_str());
16304   return jresult;
16305 }
16306
16307
16308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16309   unsigned int jresult ;
16310   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16311   Dali::TypeInfo *arg2 = 0 ;
16312   bool result;
16313
16314   arg1 = (Dali::BaseHandle *)jarg1;
16315   arg2 = (Dali::TypeInfo *)jarg2;
16316   if (!arg2) {
16317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16318     return 0;
16319   }
16320   {
16321     try {
16322       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16323     } catch (std::out_of_range& e) {
16324       {
16325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16326       };
16327     } catch (std::exception& e) {
16328       {
16329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16330       };
16331     } catch (...) {
16332       {
16333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16334       };
16335     }
16336   }
16337   jresult = result;
16338   return jresult;
16339 }
16340
16341
16342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16343   void * jresult ;
16344   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16345   Dali::BaseObject *result = 0 ;
16346
16347   arg1 = (Dali::BaseHandle *)jarg1;
16348   {
16349     try {
16350       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16351     } catch (std::out_of_range& e) {
16352       {
16353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16354       };
16355     } catch (std::exception& e) {
16356       {
16357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16358       };
16359     } catch (...) {
16360       {
16361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16362       };
16363     }
16364   }
16365   jresult = (void *)result;
16366   return jresult;
16367 }
16368
16369
16370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16371   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16372
16373   arg1 = (Dali::BaseHandle *)jarg1;
16374   {
16375     try {
16376       (arg1)->Reset();
16377     } catch (std::out_of_range& e) {
16378       {
16379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16380       };
16381     } catch (std::exception& e) {
16382       {
16383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16384       };
16385     } catch (...) {
16386       {
16387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16388       };
16389     }
16390   }
16391 }
16392
16393
16394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16395   unsigned int jresult ;
16396   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16397   Dali::BaseHandle *arg2 = 0 ;
16398   bool result;
16399
16400   arg1 = (Dali::BaseHandle *)jarg1;
16401   arg2 = (Dali::BaseHandle *)jarg2;
16402   if (!arg2) {
16403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16404     return 0;
16405   }
16406   {
16407     try {
16408       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16409     } catch (std::out_of_range& e) {
16410       {
16411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16412       };
16413     } catch (std::exception& e) {
16414       {
16415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16416       };
16417     } catch (...) {
16418       {
16419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16420       };
16421     }
16422   }
16423   jresult = result;
16424   return jresult;
16425 }
16426
16427
16428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16429   unsigned int jresult ;
16430   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16431   Dali::BaseHandle *arg2 = 0 ;
16432   bool result;
16433
16434   arg1 = (Dali::BaseHandle *)jarg1;
16435   arg2 = (Dali::BaseHandle *)jarg2;
16436   if (!arg2) {
16437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16438     return 0;
16439   }
16440   {
16441     try {
16442       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16443     } catch (std::out_of_range& e) {
16444       {
16445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16446       };
16447     } catch (std::exception& e) {
16448       {
16449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16450       };
16451     } catch (...) {
16452       {
16453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16454       };
16455     }
16456   }
16457   jresult = result;
16458   return jresult;
16459 }
16460
16461
16462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16463   void * jresult ;
16464   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16465   Dali::RefObject *result = 0 ;
16466
16467   arg1 = (Dali::BaseHandle *)jarg1;
16468   {
16469     try {
16470       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16471     } catch (std::out_of_range& e) {
16472       {
16473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16474       };
16475     } catch (std::exception& e) {
16476       {
16477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16478       };
16479     } catch (...) {
16480       {
16481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16482       };
16483     }
16484   }
16485   jresult = (void *)result;
16486   return jresult;
16487 }
16488
16489
16490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16491   unsigned int jresult ;
16492   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16493   bool result;
16494
16495   arg1 = (Dali::BaseHandle *)jarg1;
16496   {
16497     try {
16498       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16499     } catch (std::out_of_range& e) {
16500       {
16501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16502       };
16503     } catch (std::exception& e) {
16504       {
16505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16506       };
16507     } catch (...) {
16508       {
16509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16510       };
16511     }
16512   }
16513   jresult = result;
16514   return jresult;
16515 }
16516
16517
16518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16519   unsigned int jresult ;
16520   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16521   Dali::BaseHandle *arg2 = 0 ;
16522   bool result;
16523
16524   arg1 = (Dali::BaseHandle *)jarg1;
16525   arg2 = (Dali::BaseHandle *)jarg2;
16526   if (!arg2) {
16527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16528     return 0;
16529   }
16530   {
16531     try {
16532       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16533     } catch (std::out_of_range& e) {
16534       {
16535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16536       };
16537     } catch (std::exception& e) {
16538       {
16539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16540       };
16541     } catch (...) {
16542       {
16543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16544       };
16545     }
16546   }
16547   jresult = result;
16548   return jresult;
16549 }
16550
16551
16552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16553   unsigned int jresult ;
16554   Dali::BaseHandle *arg1 = 0 ;
16555   Dali::BaseHandle *arg2 = 0 ;
16556   bool result;
16557
16558   arg1 = (Dali::BaseHandle *)jarg1;
16559   if (!arg1) {
16560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16561     return 0;
16562   }
16563   arg2 = (Dali::BaseHandle *)jarg2;
16564   if (!arg2) {
16565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16566     return 0;
16567   }
16568   {
16569     try {
16570       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16571     } catch (std::out_of_range& e) {
16572       {
16573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16574       };
16575     } catch (std::exception& e) {
16576       {
16577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16578       };
16579     } catch (...) {
16580       {
16581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16582       };
16583     }
16584   }
16585   jresult = result;
16586   return jresult;
16587 }
16588
16589
16590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16591   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16592
16593   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16594   {
16595     try {
16596       delete arg1;
16597     } catch (std::out_of_range& e) {
16598       {
16599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16600       };
16601     } catch (std::exception& e) {
16602       {
16603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16604       };
16605     } catch (...) {
16606       {
16607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16608       };
16609     }
16610   }
16611 }
16612
16613
16614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16615   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16616   SlotObserver *arg2 = (SlotObserver *) 0 ;
16617   CallbackBase *arg3 = (CallbackBase *) 0 ;
16618
16619   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16620   arg2 = (SlotObserver *)jarg2;
16621   arg3 = (CallbackBase *)jarg3;
16622   {
16623     try {
16624       (arg1)->SignalConnected(arg2,arg3);
16625     } catch (std::out_of_range& e) {
16626       {
16627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16628       };
16629     } catch (std::exception& e) {
16630       {
16631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16632       };
16633     } catch (...) {
16634       {
16635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16636       };
16637     }
16638   }
16639 }
16640
16641
16642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16643   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16644
16645   arg1 = (Dali::SignalObserver *)jarg1;
16646   {
16647     try {
16648       delete arg1;
16649     } catch (std::out_of_range& e) {
16650       {
16651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16652       };
16653     } catch (std::exception& e) {
16654       {
16655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16656       };
16657     } catch (...) {
16658       {
16659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16660       };
16661     }
16662   }
16663 }
16664
16665
16666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16667   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16668   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16669   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16670
16671   arg1 = (Dali::SignalObserver *)jarg1;
16672   arg2 = (Dali::SlotObserver *)jarg2;
16673   arg3 = (Dali::CallbackBase *)jarg3;
16674   {
16675     try {
16676       (arg1)->SignalDisconnected(arg2,arg3);
16677     } catch (std::out_of_range& e) {
16678       {
16679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16680       };
16681     } catch (std::exception& e) {
16682       {
16683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16684       };
16685     } catch (...) {
16686       {
16687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16688       };
16689     }
16690   }
16691 }
16692
16693
16694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16695   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16696
16697   arg1 = (Dali::SlotObserver *)jarg1;
16698   {
16699     try {
16700       delete arg1;
16701     } catch (std::out_of_range& e) {
16702       {
16703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16704       };
16705     } catch (std::exception& e) {
16706       {
16707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16708       };
16709     } catch (...) {
16710       {
16711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16712       };
16713     }
16714   }
16715 }
16716
16717
16718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16719   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16720   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16721
16722   arg1 = (Dali::SlotObserver *)jarg1;
16723   arg2 = (Dali::CallbackBase *)jarg2;
16724   {
16725     try {
16726       (arg1)->SlotDisconnected(arg2);
16727     } catch (std::out_of_range& e) {
16728       {
16729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16730       };
16731     } catch (std::exception& e) {
16732       {
16733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16734       };
16735     } catch (...) {
16736       {
16737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16738       };
16739     }
16740   }
16741 }
16742
16743
16744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16745   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16746
16747   arg1 = (Dali::ConnectionTracker *)jarg1;
16748   {
16749     try {
16750       delete arg1;
16751     } catch (std::out_of_range& e) {
16752       {
16753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16754       };
16755     } catch (std::exception& e) {
16756       {
16757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16758       };
16759     } catch (...) {
16760       {
16761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16762       };
16763     }
16764   }
16765 }
16766
16767
16768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16769   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16770
16771   arg1 = (Dali::ConnectionTracker *)jarg1;
16772   {
16773     try {
16774       (arg1)->DisconnectAll();
16775     } catch (std::out_of_range& e) {
16776       {
16777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16778       };
16779     } catch (std::exception& e) {
16780       {
16781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16782       };
16783     } catch (...) {
16784       {
16785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16786       };
16787     }
16788   }
16789 }
16790
16791
16792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16793   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16794   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16795   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16796
16797   arg1 = (Dali::ConnectionTracker *)jarg1;
16798   arg2 = (Dali::SlotObserver *)jarg2;
16799   arg3 = (Dali::CallbackBase *)jarg3;
16800   {
16801     try {
16802       (arg1)->SignalConnected(arg2,arg3);
16803     } catch (std::out_of_range& e) {
16804       {
16805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16806       };
16807     } catch (std::exception& e) {
16808       {
16809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16810       };
16811     } catch (...) {
16812       {
16813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16814       };
16815     }
16816   }
16817 }
16818
16819
16820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16821   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16822   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16823   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16824
16825   arg1 = (Dali::ConnectionTracker *)jarg1;
16826   arg2 = (Dali::SlotObserver *)jarg2;
16827   arg3 = (Dali::CallbackBase *)jarg3;
16828   {
16829     try {
16830       (arg1)->SignalDisconnected(arg2,arg3);
16831     } catch (std::out_of_range& e) {
16832       {
16833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16834       };
16835     } catch (std::exception& e) {
16836       {
16837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16838       };
16839     } catch (...) {
16840       {
16841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16842       };
16843     }
16844   }
16845 }
16846
16847
16848 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16849   unsigned long jresult ;
16850   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16851   std::size_t result;
16852
16853   arg1 = (Dali::ConnectionTracker *)jarg1;
16854   {
16855     try {
16856       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16857     } catch (std::out_of_range& e) {
16858       {
16859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16860       };
16861     } catch (std::exception& e) {
16862       {
16863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16864       };
16865     } catch (...) {
16866       {
16867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16868       };
16869     }
16870   }
16871   jresult = (unsigned long)result;
16872   return jresult;
16873 }
16874
16875
16876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16877   void * jresult ;
16878   Dali::ObjectRegistry *result = 0 ;
16879
16880   {
16881     try {
16882       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16883     } catch (std::out_of_range& e) {
16884       {
16885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16886       };
16887     } catch (std::exception& e) {
16888       {
16889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16890       };
16891     } catch (...) {
16892       {
16893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16894       };
16895     }
16896   }
16897   jresult = (void *)result;
16898   return jresult;
16899 }
16900
16901
16902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16903   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16904
16905   arg1 = (Dali::ObjectRegistry *)jarg1;
16906   {
16907     try {
16908       delete arg1;
16909     } catch (std::out_of_range& e) {
16910       {
16911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16912       };
16913     } catch (std::exception& e) {
16914       {
16915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16916       };
16917     } catch (...) {
16918       {
16919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16920       };
16921     }
16922   }
16923 }
16924
16925
16926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16927   void * jresult ;
16928   Dali::ObjectRegistry *arg1 = 0 ;
16929   Dali::ObjectRegistry *result = 0 ;
16930
16931   arg1 = (Dali::ObjectRegistry *)jarg1;
16932   if (!arg1) {
16933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16934     return 0;
16935   }
16936   {
16937     try {
16938       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16939     } catch (std::out_of_range& e) {
16940       {
16941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16942       };
16943     } catch (std::exception& e) {
16944       {
16945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16946       };
16947     } catch (...) {
16948       {
16949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16950       };
16951     }
16952   }
16953   jresult = (void *)result;
16954   return jresult;
16955 }
16956
16957
16958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16959   void * jresult ;
16960   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16961   Dali::ObjectRegistry *arg2 = 0 ;
16962   Dali::ObjectRegistry *result = 0 ;
16963
16964   arg1 = (Dali::ObjectRegistry *)jarg1;
16965   arg2 = (Dali::ObjectRegistry *)jarg2;
16966   if (!arg2) {
16967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16968     return 0;
16969   }
16970   {
16971     try {
16972       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16973     } catch (std::out_of_range& e) {
16974       {
16975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16976       };
16977     } catch (std::exception& e) {
16978       {
16979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16980       };
16981     } catch (...) {
16982       {
16983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16984       };
16985     }
16986   }
16987   jresult = (void *)result;
16988   return jresult;
16989 }
16990
16991
16992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
16993   void * jresult ;
16994   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16995   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
16996
16997   arg1 = (Dali::ObjectRegistry *)jarg1;
16998   {
16999     try {
17000       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17001     } catch (std::out_of_range& e) {
17002       {
17003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17004       };
17005     } catch (std::exception& e) {
17006       {
17007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17008       };
17009     } catch (...) {
17010       {
17011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17012       };
17013     }
17014   }
17015   jresult = (void *)result;
17016   return jresult;
17017 }
17018
17019
17020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17021   void * jresult ;
17022   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17023   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17024
17025   arg1 = (Dali::ObjectRegistry *)jarg1;
17026   {
17027     try {
17028       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17029     } catch (std::out_of_range& e) {
17030       {
17031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17032       };
17033     } catch (std::exception& e) {
17034       {
17035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17036       };
17037     } catch (...) {
17038       {
17039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17040       };
17041     }
17042   }
17043   jresult = (void *)result;
17044   return jresult;
17045 }
17046
17047
17048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17049   void * jresult ;
17050   Dali::PropertyCondition *result = 0 ;
17051
17052   {
17053     try {
17054       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17055     } catch (std::out_of_range& e) {
17056       {
17057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17058       };
17059     } catch (std::exception& e) {
17060       {
17061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17062       };
17063     } catch (...) {
17064       {
17065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17066       };
17067     }
17068   }
17069   jresult = (void *)result;
17070   return jresult;
17071 }
17072
17073
17074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17075   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17076
17077   arg1 = (Dali::PropertyCondition *)jarg1;
17078   {
17079     try {
17080       delete arg1;
17081     } catch (std::out_of_range& e) {
17082       {
17083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17084       };
17085     } catch (std::exception& e) {
17086       {
17087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17088       };
17089     } catch (...) {
17090       {
17091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17092       };
17093     }
17094   }
17095 }
17096
17097
17098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17099   void * jresult ;
17100   Dali::PropertyCondition *arg1 = 0 ;
17101   Dali::PropertyCondition *result = 0 ;
17102
17103   arg1 = (Dali::PropertyCondition *)jarg1;
17104   if (!arg1) {
17105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17106     return 0;
17107   }
17108   {
17109     try {
17110       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17111     } catch (std::out_of_range& e) {
17112       {
17113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17114       };
17115     } catch (std::exception& e) {
17116       {
17117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17118       };
17119     } catch (...) {
17120       {
17121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17122       };
17123     }
17124   }
17125   jresult = (void *)result;
17126   return jresult;
17127 }
17128
17129
17130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17131   void * jresult ;
17132   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17133   Dali::PropertyCondition *arg2 = 0 ;
17134   Dali::PropertyCondition *result = 0 ;
17135
17136   arg1 = (Dali::PropertyCondition *)jarg1;
17137   arg2 = (Dali::PropertyCondition *)jarg2;
17138   if (!arg2) {
17139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17140     return 0;
17141   }
17142   {
17143     try {
17144       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17145     } catch (std::out_of_range& e) {
17146       {
17147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17148       };
17149     } catch (std::exception& e) {
17150       {
17151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17152       };
17153     } catch (...) {
17154       {
17155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17156       };
17157     }
17158   }
17159   jresult = (void *)result;
17160   return jresult;
17161 }
17162
17163
17164 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17165   unsigned long jresult ;
17166   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17167   std::size_t result;
17168
17169   arg1 = (Dali::PropertyCondition *)jarg1;
17170   {
17171     try {
17172       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17173     } catch (std::out_of_range& e) {
17174       {
17175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17176       };
17177     } catch (std::exception& e) {
17178       {
17179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17180       };
17181     } catch (...) {
17182       {
17183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17184       };
17185     }
17186   }
17187   jresult = (unsigned long)result;
17188   return jresult;
17189 }
17190
17191
17192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17193   float jresult ;
17194   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17195   std::size_t arg2 ;
17196   float result;
17197
17198   arg1 = (Dali::PropertyCondition *)jarg1;
17199   arg2 = (std::size_t)jarg2;
17200   {
17201     try {
17202       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17203     } catch (std::out_of_range& e) {
17204       {
17205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17206       };
17207     } catch (std::exception& e) {
17208       {
17209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17210       };
17211     } catch (...) {
17212       {
17213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17214       };
17215     }
17216   }
17217   jresult = result;
17218   return jresult;
17219 }
17220
17221
17222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17223   void * jresult ;
17224   float arg1 ;
17225   Dali::PropertyCondition result;
17226
17227   arg1 = (float)jarg1;
17228   {
17229     try {
17230       result = Dali::LessThanCondition(arg1);
17231     } catch (std::out_of_range& e) {
17232       {
17233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17234       };
17235     } catch (std::exception& e) {
17236       {
17237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17238       };
17239     } catch (...) {
17240       {
17241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17242       };
17243     }
17244   }
17245   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17246   return jresult;
17247 }
17248
17249
17250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17251   void * jresult ;
17252   float arg1 ;
17253   Dali::PropertyCondition result;
17254
17255   arg1 = (float)jarg1;
17256   {
17257     try {
17258       result = Dali::GreaterThanCondition(arg1);
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 (...) {
17268       {
17269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17270       };
17271     }
17272   }
17273   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17274   return jresult;
17275 }
17276
17277
17278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17279   void * jresult ;
17280   float arg1 ;
17281   float arg2 ;
17282   Dali::PropertyCondition result;
17283
17284   arg1 = (float)jarg1;
17285   arg2 = (float)jarg2;
17286   {
17287     try {
17288       result = Dali::InsideCondition(arg1,arg2);
17289     } catch (std::out_of_range& e) {
17290       {
17291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17292       };
17293     } catch (std::exception& e) {
17294       {
17295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17296       };
17297     } catch (...) {
17298       {
17299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17300       };
17301     }
17302   }
17303   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17304   return jresult;
17305 }
17306
17307
17308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17309   void * jresult ;
17310   float arg1 ;
17311   float arg2 ;
17312   Dali::PropertyCondition result;
17313
17314   arg1 = (float)jarg1;
17315   arg2 = (float)jarg2;
17316   {
17317     try {
17318       result = Dali::OutsideCondition(arg1,arg2);
17319     } catch (std::out_of_range& e) {
17320       {
17321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17322       };
17323     } catch (std::exception& e) {
17324       {
17325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17326       };
17327     } catch (...) {
17328       {
17329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17330       };
17331     }
17332   }
17333   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17334   return jresult;
17335 }
17336
17337
17338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17339   void * jresult ;
17340   float arg1 ;
17341   float arg2 ;
17342   Dali::PropertyCondition result;
17343
17344   arg1 = (float)jarg1;
17345   arg2 = (float)jarg2;
17346   {
17347     try {
17348       result = Dali::StepCondition(arg1,arg2);
17349     } catch (std::out_of_range& e) {
17350       {
17351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17352       };
17353     } catch (std::exception& e) {
17354       {
17355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17356       };
17357     } catch (...) {
17358       {
17359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17360       };
17361     }
17362   }
17363   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17364   return jresult;
17365 }
17366
17367
17368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17369   void * jresult ;
17370   float arg1 ;
17371   Dali::PropertyCondition result;
17372
17373   arg1 = (float)jarg1;
17374   {
17375     try {
17376       result = Dali::StepCondition(arg1);
17377     } catch (std::out_of_range& e) {
17378       {
17379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17380       };
17381     } catch (std::exception& e) {
17382       {
17383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17384       };
17385     } catch (...) {
17386       {
17387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17388       };
17389     }
17390   }
17391   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17392   return jresult;
17393 }
17394
17395
17396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17397   void * jresult ;
17398   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17399   Dali::PropertyCondition result;
17400
17401   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17402   if (!arg1) {
17403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17404     return 0;
17405   }
17406   {
17407     try {
17408       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17409     } catch (std::out_of_range& e) {
17410       {
17411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17412       };
17413     } catch (std::exception& e) {
17414       {
17415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17416       };
17417     } catch (...) {
17418       {
17419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17420       };
17421     }
17422   }
17423   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17424   return jresult;
17425 }
17426
17427
17428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17429   void * jresult ;
17430   Dali::PropertyNotification *result = 0 ;
17431
17432   {
17433     try {
17434       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17435     } catch (std::out_of_range& e) {
17436       {
17437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17438       };
17439     } catch (std::exception& e) {
17440       {
17441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17442       };
17443     } catch (...) {
17444       {
17445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17446       };
17447     }
17448   }
17449   jresult = (void *)result;
17450   return jresult;
17451 }
17452
17453
17454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17455   void * jresult ;
17456   Dali::BaseHandle arg1 ;
17457   Dali::BaseHandle *argp1 ;
17458   Dali::PropertyNotification result;
17459
17460   argp1 = (Dali::BaseHandle *)jarg1;
17461   if (!argp1) {
17462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17463     return 0;
17464   }
17465   arg1 = *argp1;
17466   {
17467     try {
17468       result = Dali::PropertyNotification::DownCast(arg1);
17469     } catch (std::out_of_range& e) {
17470       {
17471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17472       };
17473     } catch (std::exception& e) {
17474       {
17475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17476       };
17477     } catch (...) {
17478       {
17479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17480       };
17481     }
17482   }
17483   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17484   return jresult;
17485 }
17486
17487
17488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17489   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17490
17491   arg1 = (Dali::PropertyNotification *)jarg1;
17492   {
17493     try {
17494       delete arg1;
17495     } catch (std::out_of_range& e) {
17496       {
17497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17498       };
17499     } catch (std::exception& e) {
17500       {
17501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17502       };
17503     } catch (...) {
17504       {
17505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17506       };
17507     }
17508   }
17509 }
17510
17511
17512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17513   void * jresult ;
17514   Dali::PropertyNotification *arg1 = 0 ;
17515   Dali::PropertyNotification *result = 0 ;
17516
17517   arg1 = (Dali::PropertyNotification *)jarg1;
17518   if (!arg1) {
17519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17520     return 0;
17521   }
17522   {
17523     try {
17524       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17525     } catch (std::out_of_range& e) {
17526       {
17527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17528       };
17529     } catch (std::exception& e) {
17530       {
17531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17532       };
17533     } catch (...) {
17534       {
17535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17536       };
17537     }
17538   }
17539   jresult = (void *)result;
17540   return jresult;
17541 }
17542
17543
17544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17545   void * jresult ;
17546   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17547   Dali::PropertyNotification *arg2 = 0 ;
17548   Dali::PropertyNotification *result = 0 ;
17549
17550   arg1 = (Dali::PropertyNotification *)jarg1;
17551   arg2 = (Dali::PropertyNotification *)jarg2;
17552   if (!arg2) {
17553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17554     return 0;
17555   }
17556   {
17557     try {
17558       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17559     } catch (std::out_of_range& e) {
17560       {
17561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17562       };
17563     } catch (std::exception& e) {
17564       {
17565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17566       };
17567     } catch (...) {
17568       {
17569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17570       };
17571     }
17572   }
17573   jresult = (void *)result;
17574   return jresult;
17575 }
17576
17577
17578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17579   void * jresult ;
17580   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17581   Dali::PropertyCondition result;
17582
17583   arg1 = (Dali::PropertyNotification *)jarg1;
17584   {
17585     try {
17586       result = (arg1)->GetCondition();
17587     } catch (std::out_of_range& e) {
17588       {
17589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17590       };
17591     } catch (std::exception& e) {
17592       {
17593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17594       };
17595     } catch (...) {
17596       {
17597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17598       };
17599     }
17600   }
17601   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17602   return jresult;
17603 }
17604
17605
17606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17607   void * jresult ;
17608   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17609   Dali::Handle result;
17610
17611   arg1 = (Dali::PropertyNotification *)jarg1;
17612   {
17613     try {
17614       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17615     } catch (std::out_of_range& e) {
17616       {
17617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17618       };
17619     } catch (std::exception& e) {
17620       {
17621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17622       };
17623     } catch (...) {
17624       {
17625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17626       };
17627     }
17628   }
17629   jresult = new Dali::Handle((const Dali::Handle &)result);
17630   return jresult;
17631 }
17632
17633
17634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17635   int jresult ;
17636   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17637   Dali::Property::Index result;
17638
17639   arg1 = (Dali::PropertyNotification *)jarg1;
17640   {
17641     try {
17642       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17643     } catch (std::out_of_range& e) {
17644       {
17645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17646       };
17647     } catch (std::exception& e) {
17648       {
17649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17650       };
17651     } catch (...) {
17652       {
17653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17654       };
17655     }
17656   }
17657   jresult = result;
17658   return jresult;
17659 }
17660
17661
17662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17663   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17664   Dali::PropertyNotification::NotifyMode arg2 ;
17665
17666   arg1 = (Dali::PropertyNotification *)jarg1;
17667   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17668   {
17669     try {
17670       (arg1)->SetNotifyMode(arg2);
17671     } catch (std::out_of_range& e) {
17672       {
17673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17674       };
17675     } catch (std::exception& e) {
17676       {
17677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17678       };
17679     } catch (...) {
17680       {
17681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17682       };
17683     }
17684   }
17685 }
17686
17687
17688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17689   int jresult ;
17690   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17691   Dali::PropertyNotification::NotifyMode result;
17692
17693   arg1 = (Dali::PropertyNotification *)jarg1;
17694   {
17695     try {
17696       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17697     } catch (std::out_of_range& e) {
17698       {
17699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17700       };
17701     } catch (std::exception& e) {
17702       {
17703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17704       };
17705     } catch (...) {
17706       {
17707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17708       };
17709     }
17710   }
17711   jresult = (int)result;
17712   return jresult;
17713 }
17714
17715
17716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17717   unsigned int jresult ;
17718   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17719   bool result;
17720
17721   arg1 = (Dali::PropertyNotification *)jarg1;
17722   {
17723     try {
17724       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17725     } catch (std::out_of_range& e) {
17726       {
17727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17728       };
17729     } catch (std::exception& e) {
17730       {
17731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17732       };
17733     } catch (...) {
17734       {
17735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17736       };
17737     }
17738   }
17739   jresult = result;
17740   return jresult;
17741 }
17742
17743
17744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17745   void * jresult ;
17746   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17747   Dali::PropertyNotifySignalType *result = 0 ;
17748
17749   arg1 = (Dali::PropertyNotification *)jarg1;
17750   {
17751     try {
17752       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17753     } catch (std::out_of_range& e) {
17754       {
17755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17756       };
17757     } catch (std::exception& e) {
17758       {
17759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17760       };
17761     } catch (...) {
17762       {
17763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17764       };
17765     }
17766   }
17767   jresult = (void *)result;
17768   return jresult;
17769 }
17770
17771
17772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17773   void * jresult ;
17774   Dali::Handle *result = 0 ;
17775
17776   {
17777     try {
17778       result = (Dali::Handle *)new Dali::Handle();
17779     } catch (std::out_of_range& e) {
17780       {
17781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17782       };
17783     } catch (std::exception& e) {
17784       {
17785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17786       };
17787     } catch (...) {
17788       {
17789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17790       };
17791     }
17792   }
17793   jresult = (void *)result;
17794   return jresult;
17795 }
17796
17797
17798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17799   void * jresult ;
17800   Dali::Handle result;
17801
17802   {
17803     try {
17804       result = Dali::Handle::New();
17805     } catch (std::out_of_range& e) {
17806       {
17807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17808       };
17809     } catch (std::exception& e) {
17810       {
17811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17812       };
17813     } catch (...) {
17814       {
17815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17816       };
17817     }
17818   }
17819   jresult = new Dali::Handle((const Dali::Handle &)result);
17820   return jresult;
17821 }
17822
17823
17824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17825   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17826
17827   arg1 = (Dali::Handle *)jarg1;
17828   {
17829     try {
17830       delete arg1;
17831     } catch (std::out_of_range& e) {
17832       {
17833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17834       };
17835     } catch (std::exception& e) {
17836       {
17837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17838       };
17839     } catch (...) {
17840       {
17841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17842       };
17843     }
17844   }
17845 }
17846
17847
17848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17849   void * jresult ;
17850   Dali::Handle *arg1 = 0 ;
17851   Dali::Handle *result = 0 ;
17852
17853   arg1 = (Dali::Handle *)jarg1;
17854   if (!arg1) {
17855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17856     return 0;
17857   }
17858   {
17859     try {
17860       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17861     } catch (std::out_of_range& e) {
17862       {
17863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17864       };
17865     } catch (std::exception& e) {
17866       {
17867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17868       };
17869     } catch (...) {
17870       {
17871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17872       };
17873     }
17874   }
17875   jresult = (void *)result;
17876   return jresult;
17877 }
17878
17879
17880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17881   void * jresult ;
17882   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17883   Dali::Handle *arg2 = 0 ;
17884   Dali::Handle *result = 0 ;
17885
17886   arg1 = (Dali::Handle *)jarg1;
17887   arg2 = (Dali::Handle *)jarg2;
17888   if (!arg2) {
17889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17890     return 0;
17891   }
17892   {
17893     try {
17894       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17895     } catch (std::out_of_range& e) {
17896       {
17897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17898       };
17899     } catch (std::exception& e) {
17900       {
17901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17902       };
17903     } catch (...) {
17904       {
17905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17906       };
17907     }
17908   }
17909   jresult = (void *)result;
17910   return jresult;
17911 }
17912
17913
17914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17915   void * jresult ;
17916   Dali::BaseHandle arg1 ;
17917   Dali::BaseHandle *argp1 ;
17918   Dali::Handle result;
17919
17920   argp1 = (Dali::BaseHandle *)jarg1;
17921   if (!argp1) {
17922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17923     return 0;
17924   }
17925   arg1 = *argp1;
17926   {
17927     try {
17928       result = Dali::Handle::DownCast(arg1);
17929     } catch (std::out_of_range& e) {
17930       {
17931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17932       };
17933     } catch (std::exception& e) {
17934       {
17935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17936       };
17937     } catch (...) {
17938       {
17939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17940       };
17941     }
17942   }
17943   jresult = new Dali::Handle((const Dali::Handle &)result);
17944   return jresult;
17945 }
17946
17947
17948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17949   unsigned int jresult ;
17950   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17951   Dali::Handle::Capability arg2 ;
17952   bool result;
17953
17954   arg1 = (Dali::Handle *)jarg1;
17955   arg2 = (Dali::Handle::Capability)jarg2;
17956   {
17957     try {
17958       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17959     } catch (std::out_of_range& e) {
17960       {
17961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17962       };
17963     } catch (std::exception& e) {
17964       {
17965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17966       };
17967     } catch (...) {
17968       {
17969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17970       };
17971     }
17972   }
17973   jresult = result;
17974   return jresult;
17975 }
17976
17977
17978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17979   unsigned int jresult ;
17980   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17981   unsigned int result;
17982
17983   arg1 = (Dali::Handle *)jarg1;
17984   {
17985     try {
17986       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
17987     } catch (std::out_of_range& e) {
17988       {
17989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17990       };
17991     } catch (std::exception& e) {
17992       {
17993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17994       };
17995     } catch (...) {
17996       {
17997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17998       };
17999     }
18000   }
18001   jresult = result;
18002   return jresult;
18003 }
18004
18005
18006 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18007   char * jresult ;
18008   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18009   Dali::Property::Index arg2 ;
18010   std::string result;
18011
18012   arg1 = (Dali::Handle *)jarg1;
18013   arg2 = (Dali::Property::Index)jarg2;
18014   {
18015     try {
18016       result = ((Dali::Handle const *)arg1)->GetPropertyName(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 (...) {
18026       {
18027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18028       };
18029     }
18030   }
18031   jresult = SWIG_csharp_string_callback((&result)->c_str());
18032   return jresult;
18033 }
18034
18035
18036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18037   int jresult ;
18038   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18039   std::string *arg2 = 0 ;
18040   Dali::Property::Index result;
18041
18042   arg1 = (Dali::Handle *)jarg1;
18043   if (!jarg2) {
18044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18045     return 0;
18046   }
18047   std::string arg2_str(jarg2);
18048   arg2 = &arg2_str;
18049   {
18050     try {
18051       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18052     } catch (std::out_of_range& e) {
18053       {
18054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18055       };
18056     } catch (std::exception& e) {
18057       {
18058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18059       };
18060     } catch (...) {
18061       {
18062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18063       };
18064     }
18065   }
18066   jresult = result;
18067
18068   //argout typemap for const std::string&
18069
18070   return jresult;
18071 }
18072
18073
18074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18075   unsigned int jresult ;
18076   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18077   Dali::Property::Index arg2 ;
18078   bool result;
18079
18080   arg1 = (Dali::Handle *)jarg1;
18081   arg2 = (Dali::Property::Index)jarg2;
18082   {
18083     try {
18084       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18085     } catch (std::out_of_range& e) {
18086       {
18087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18088       };
18089     } catch (std::exception& e) {
18090       {
18091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18092       };
18093     } catch (...) {
18094       {
18095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18096       };
18097     }
18098   }
18099   jresult = result;
18100   return jresult;
18101 }
18102
18103
18104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18105   unsigned int jresult ;
18106   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18107   Dali::Property::Index arg2 ;
18108   bool result;
18109
18110   arg1 = (Dali::Handle *)jarg1;
18111   arg2 = (Dali::Property::Index)jarg2;
18112   {
18113     try {
18114       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18115     } catch (std::out_of_range& e) {
18116       {
18117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18118       };
18119     } catch (std::exception& e) {
18120       {
18121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18122       };
18123     } catch (...) {
18124       {
18125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18126       };
18127     }
18128   }
18129   jresult = result;
18130   return jresult;
18131 }
18132
18133
18134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18135   unsigned int jresult ;
18136   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18137   Dali::Property::Index arg2 ;
18138   bool result;
18139
18140   arg1 = (Dali::Handle *)jarg1;
18141   arg2 = (Dali::Property::Index)jarg2;
18142   {
18143     try {
18144       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18145     } catch (std::out_of_range& e) {
18146       {
18147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18148       };
18149     } catch (std::exception& e) {
18150       {
18151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18152       };
18153     } catch (...) {
18154       {
18155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18156       };
18157     }
18158   }
18159   jresult = result;
18160   return jresult;
18161 }
18162
18163
18164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18165   int jresult ;
18166   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18167   Dali::Property::Index arg2 ;
18168   Dali::Property::Type result;
18169
18170   arg1 = (Dali::Handle *)jarg1;
18171   arg2 = (Dali::Property::Index)jarg2;
18172   {
18173     try {
18174       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18175     } catch (std::out_of_range& e) {
18176       {
18177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18178       };
18179     } catch (std::exception& e) {
18180       {
18181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18182       };
18183     } catch (...) {
18184       {
18185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18186       };
18187     }
18188   }
18189   jresult = (int)result;
18190   return jresult;
18191 }
18192
18193
18194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18195   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18196   Dali::Property::Index arg2 ;
18197   Dali::Property::Value *arg3 = 0 ;
18198
18199   arg1 = (Dali::Handle *)jarg1;
18200   arg2 = (Dali::Property::Index)jarg2;
18201   arg3 = (Dali::Property::Value *)jarg3;
18202   if (!arg3) {
18203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18204     return ;
18205   }
18206   {
18207     try {
18208       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18209     } catch (std::out_of_range& e) {
18210       {
18211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18212       };
18213     } catch (std::exception& e) {
18214       {
18215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18216       };
18217     } catch (...) {
18218       {
18219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18220       };
18221     }
18222   }
18223 }
18224
18225
18226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18227   int jresult ;
18228   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18229   std::string *arg2 = 0 ;
18230   Dali::Property::Value *arg3 = 0 ;
18231   Dali::Property::Index result;
18232
18233   arg1 = (Dali::Handle *)jarg1;
18234   if (!jarg2) {
18235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18236     return 0;
18237   }
18238   std::string arg2_str(jarg2);
18239   arg2 = &arg2_str;
18240   arg3 = (Dali::Property::Value *)jarg3;
18241   if (!arg3) {
18242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18243     return 0;
18244   }
18245   {
18246     try {
18247       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18248     } catch (std::out_of_range& e) {
18249       {
18250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18251       };
18252     } catch (std::exception& e) {
18253       {
18254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18255       };
18256     } catch (...) {
18257       {
18258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18259       };
18260     }
18261   }
18262   jresult = result;
18263
18264   //argout typemap for const std::string&
18265
18266   return jresult;
18267 }
18268
18269
18270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18271   int jresult ;
18272   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18273   std::string *arg2 = 0 ;
18274   Dali::Property::Value *arg3 = 0 ;
18275   Dali::Property::AccessMode arg4 ;
18276   Dali::Property::Index result;
18277
18278   arg1 = (Dali::Handle *)jarg1;
18279   if (!jarg2) {
18280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18281     return 0;
18282   }
18283   std::string arg2_str(jarg2);
18284   arg2 = &arg2_str;
18285   arg3 = (Dali::Property::Value *)jarg3;
18286   if (!arg3) {
18287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18288     return 0;
18289   }
18290   arg4 = (Dali::Property::AccessMode)jarg4;
18291   {
18292     try {
18293       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18294     } catch (std::out_of_range& e) {
18295       {
18296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18297       };
18298     } catch (std::exception& e) {
18299       {
18300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18301       };
18302     } catch (...) {
18303       {
18304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18305       };
18306     }
18307   }
18308   jresult = result;
18309
18310   //argout typemap for const std::string&
18311
18312   return jresult;
18313 }
18314
18315
18316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18317   void * jresult ;
18318   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18319   Dali::Property::Index arg2 ;
18320   Dali::Property::Value result;
18321
18322   arg1 = (Dali::Handle *)jarg1;
18323   arg2 = (Dali::Property::Index)jarg2;
18324   {
18325     try {
18326       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18327     } catch (std::out_of_range& e) {
18328       {
18329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18330       };
18331     } catch (std::exception& e) {
18332       {
18333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18334       };
18335     } catch (...) {
18336       {
18337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18338       };
18339     }
18340   }
18341   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18342   return jresult;
18343 }
18344
18345
18346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18347   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18348   Dali::Property::IndexContainer *arg2 = 0 ;
18349
18350   arg1 = (Dali::Handle *)jarg1;
18351   arg2 = (Dali::Property::IndexContainer *)jarg2;
18352   if (!arg2) {
18353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18354     return ;
18355   }
18356   {
18357     try {
18358       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18359     } catch (std::out_of_range& e) {
18360       {
18361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18362       };
18363     } catch (std::exception& e) {
18364       {
18365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18366       };
18367     } catch (...) {
18368       {
18369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18370       };
18371     }
18372   }
18373 }
18374
18375
18376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18377   void * jresult ;
18378   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18379   Dali::Property::Index arg2 ;
18380   Dali::PropertyCondition *arg3 = 0 ;
18381   Dali::PropertyNotification result;
18382
18383   arg1 = (Dali::Handle *)jarg1;
18384   arg2 = (Dali::Property::Index)jarg2;
18385   arg3 = (Dali::PropertyCondition *)jarg3;
18386   if (!arg3) {
18387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18388     return 0;
18389   }
18390   {
18391     try {
18392       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18393     } catch (std::out_of_range& e) {
18394       {
18395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18396       };
18397     } catch (std::exception& e) {
18398       {
18399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18400       };
18401     } catch (...) {
18402       {
18403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18404       };
18405     }
18406   }
18407   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18408   return jresult;
18409 }
18410
18411
18412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18413   void * jresult ;
18414   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18415   Dali::Property::Index arg2 ;
18416   int arg3 ;
18417   Dali::PropertyCondition *arg4 = 0 ;
18418   Dali::PropertyNotification result;
18419
18420   arg1 = (Dali::Handle *)jarg1;
18421   arg2 = (Dali::Property::Index)jarg2;
18422   arg3 = (int)jarg3;
18423   arg4 = (Dali::PropertyCondition *)jarg4;
18424   if (!arg4) {
18425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18426     return 0;
18427   }
18428   {
18429     try {
18430       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18431     } catch (std::out_of_range& e) {
18432       {
18433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18434       };
18435     } catch (std::exception& e) {
18436       {
18437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18438       };
18439     } catch (...) {
18440       {
18441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18442       };
18443     }
18444   }
18445   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18446   return jresult;
18447 }
18448
18449
18450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18451   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18452   Dali::PropertyNotification arg2 ;
18453   Dali::PropertyNotification *argp2 ;
18454
18455   arg1 = (Dali::Handle *)jarg1;
18456   argp2 = (Dali::PropertyNotification *)jarg2;
18457   if (!argp2) {
18458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18459     return ;
18460   }
18461   arg2 = *argp2;
18462   {
18463     try {
18464       (arg1)->RemovePropertyNotification(arg2);
18465     } catch (std::out_of_range& e) {
18466       {
18467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18468       };
18469     } catch (std::exception& e) {
18470       {
18471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18472       };
18473     } catch (...) {
18474       {
18475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18476       };
18477     }
18478   }
18479 }
18480
18481
18482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18483   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18484
18485   arg1 = (Dali::Handle *)jarg1;
18486   {
18487     try {
18488       (arg1)->RemovePropertyNotifications();
18489     } catch (std::out_of_range& e) {
18490       {
18491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18492       };
18493     } catch (std::exception& e) {
18494       {
18495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18496       };
18497     } catch (...) {
18498       {
18499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18500       };
18501     }
18502   }
18503 }
18504
18505
18506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18507   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18508
18509   arg1 = (Dali::Handle *)jarg1;
18510   {
18511     try {
18512       (arg1)->RemoveConstraints();
18513     } catch (std::out_of_range& e) {
18514       {
18515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18516       };
18517     } catch (std::exception& e) {
18518       {
18519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18520       };
18521     } catch (...) {
18522       {
18523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18524       };
18525     }
18526   }
18527 }
18528
18529
18530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18531   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18532   unsigned int arg2 ;
18533
18534   arg1 = (Dali::Handle *)jarg1;
18535   arg2 = (unsigned int)jarg2;
18536   {
18537     try {
18538       (arg1)->RemoveConstraints(arg2);
18539     } catch (std::out_of_range& e) {
18540       {
18541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18542       };
18543     } catch (std::exception& e) {
18544       {
18545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18546       };
18547     } catch (...) {
18548       {
18549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18550       };
18551     }
18552   }
18553 }
18554
18555
18556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18557   int jresult ;
18558   Dali::Property::Index result;
18559
18560   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18561   jresult = result;
18562   return jresult;
18563 }
18564
18565
18566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18567   void * jresult ;
18568   Dali::Handle result;
18569
18570   {
18571     try {
18572       result = Dali::WeightObject::New();
18573     } catch (std::out_of_range& e) {
18574       {
18575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18576       };
18577     } catch (std::exception& e) {
18578       {
18579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18580       };
18581     } catch (...) {
18582       {
18583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18584       };
18585     }
18586   }
18587   jresult = new Dali::Handle((const Dali::Handle &)result);
18588   return jresult;
18589 }
18590
18591
18592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18593   void * jresult ;
18594   Dali::TypeInfo *result = 0 ;
18595
18596   {
18597     try {
18598       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18599     } catch (std::out_of_range& e) {
18600       {
18601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18602       };
18603     } catch (std::exception& e) {
18604       {
18605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18606       };
18607     } catch (...) {
18608       {
18609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18610       };
18611     }
18612   }
18613   jresult = (void *)result;
18614   return jresult;
18615 }
18616
18617
18618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18619   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18620
18621   arg1 = (Dali::TypeInfo *)jarg1;
18622   {
18623     try {
18624       delete arg1;
18625     } catch (std::out_of_range& e) {
18626       {
18627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18628       };
18629     } catch (std::exception& e) {
18630       {
18631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18632       };
18633     } catch (...) {
18634       {
18635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18636       };
18637     }
18638   }
18639 }
18640
18641
18642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18643   void * jresult ;
18644   Dali::TypeInfo *arg1 = 0 ;
18645   Dali::TypeInfo *result = 0 ;
18646
18647   arg1 = (Dali::TypeInfo *)jarg1;
18648   if (!arg1) {
18649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18650     return 0;
18651   }
18652   {
18653     try {
18654       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18655     } catch (std::out_of_range& e) {
18656       {
18657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18658       };
18659     } catch (std::exception& e) {
18660       {
18661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18662       };
18663     } catch (...) {
18664       {
18665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18666       };
18667     }
18668   }
18669   jresult = (void *)result;
18670   return jresult;
18671 }
18672
18673
18674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18675   void * jresult ;
18676   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18677   Dali::TypeInfo *arg2 = 0 ;
18678   Dali::TypeInfo *result = 0 ;
18679
18680   arg1 = (Dali::TypeInfo *)jarg1;
18681   arg2 = (Dali::TypeInfo *)jarg2;
18682   if (!arg2) {
18683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18684     return 0;
18685   }
18686   {
18687     try {
18688       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18689     } catch (std::out_of_range& e) {
18690       {
18691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18692       };
18693     } catch (std::exception& e) {
18694       {
18695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18696       };
18697     } catch (...) {
18698       {
18699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18700       };
18701     }
18702   }
18703   jresult = (void *)result;
18704   return jresult;
18705 }
18706
18707
18708 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18709   char * jresult ;
18710   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18711   std::string *result = 0 ;
18712
18713   arg1 = (Dali::TypeInfo *)jarg1;
18714   {
18715     try {
18716       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18717     } catch (std::out_of_range& e) {
18718       {
18719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18720       };
18721     } catch (std::exception& e) {
18722       {
18723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18724       };
18725     } catch (...) {
18726       {
18727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18728       };
18729     }
18730   }
18731   jresult = SWIG_csharp_string_callback(result->c_str());
18732   return jresult;
18733 }
18734
18735
18736 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18737   char * jresult ;
18738   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18739   std::string *result = 0 ;
18740
18741   arg1 = (Dali::TypeInfo *)jarg1;
18742   {
18743     try {
18744       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18745     } catch (std::out_of_range& e) {
18746       {
18747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18748       };
18749     } catch (std::exception& e) {
18750       {
18751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18752       };
18753     } catch (...) {
18754       {
18755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18756       };
18757     }
18758   }
18759   jresult = SWIG_csharp_string_callback(result->c_str());
18760   return jresult;
18761 }
18762
18763
18764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18765   void * jresult ;
18766   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18767   Dali::BaseHandle result;
18768
18769   arg1 = (Dali::TypeInfo *)jarg1;
18770   {
18771     try {
18772       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18773     } catch (std::out_of_range& e) {
18774       {
18775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18776       };
18777     } catch (std::exception& e) {
18778       {
18779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18780       };
18781     } catch (...) {
18782       {
18783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18784       };
18785     }
18786   }
18787   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18788   return jresult;
18789 }
18790
18791
18792 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18793   unsigned long jresult ;
18794   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18795   size_t result;
18796
18797   arg1 = (Dali::TypeInfo *)jarg1;
18798   {
18799     try {
18800       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18801     } catch (std::out_of_range& e) {
18802       {
18803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18804       };
18805     } catch (std::exception& e) {
18806       {
18807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18808       };
18809     } catch (...) {
18810       {
18811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18812       };
18813     }
18814   }
18815   jresult = (unsigned long)result;
18816   return jresult;
18817 }
18818
18819
18820 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18821   char * jresult ;
18822   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18823   size_t arg2 ;
18824   std::string result;
18825
18826   arg1 = (Dali::TypeInfo *)jarg1;
18827   arg2 = (size_t)jarg2;
18828   {
18829     try {
18830       result = (arg1)->GetActionName(arg2);
18831     } catch (std::out_of_range& e) {
18832       {
18833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18834       };
18835     } catch (std::exception& e) {
18836       {
18837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18838       };
18839     } catch (...) {
18840       {
18841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18842       };
18843     }
18844   }
18845   jresult = SWIG_csharp_string_callback((&result)->c_str());
18846   return jresult;
18847 }
18848
18849
18850 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18851   unsigned long jresult ;
18852   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18853   size_t result;
18854
18855   arg1 = (Dali::TypeInfo *)jarg1;
18856   {
18857     try {
18858       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18859     } catch (std::out_of_range& e) {
18860       {
18861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18862       };
18863     } catch (std::exception& e) {
18864       {
18865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18866       };
18867     } catch (...) {
18868       {
18869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18870       };
18871     }
18872   }
18873   jresult = (unsigned long)result;
18874   return jresult;
18875 }
18876
18877
18878 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18879   char * jresult ;
18880   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18881   size_t arg2 ;
18882   std::string result;
18883
18884   arg1 = (Dali::TypeInfo *)jarg1;
18885   arg2 = (size_t)jarg2;
18886   {
18887     try {
18888       result = (arg1)->GetSignalName(arg2);
18889     } catch (std::out_of_range& e) {
18890       {
18891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18892       };
18893     } catch (std::exception& e) {
18894       {
18895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18896       };
18897     } catch (...) {
18898       {
18899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18900       };
18901     }
18902   }
18903   jresult = SWIG_csharp_string_callback((&result)->c_str());
18904   return jresult;
18905 }
18906
18907
18908 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18909   unsigned long jresult ;
18910   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18911   size_t result;
18912
18913   arg1 = (Dali::TypeInfo *)jarg1;
18914   {
18915     try {
18916       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18917     } catch (std::out_of_range& e) {
18918       {
18919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18920       };
18921     } catch (std::exception& e) {
18922       {
18923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18924       };
18925     } catch (...) {
18926       {
18927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18928       };
18929     }
18930   }
18931   jresult = (unsigned long)result;
18932   return jresult;
18933 }
18934
18935
18936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18937   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18938   Dali::Property::IndexContainer *arg2 = 0 ;
18939
18940   arg1 = (Dali::TypeInfo *)jarg1;
18941   arg2 = (Dali::Property::IndexContainer *)jarg2;
18942   if (!arg2) {
18943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18944     return ;
18945   }
18946   {
18947     try {
18948       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18949     } catch (std::out_of_range& e) {
18950       {
18951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18952       };
18953     } catch (std::exception& e) {
18954       {
18955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18956       };
18957     } catch (...) {
18958       {
18959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18960       };
18961     }
18962   }
18963 }
18964
18965
18966 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18967   char * jresult ;
18968   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18969   Dali::Property::Index arg2 ;
18970   std::string *result = 0 ;
18971
18972   arg1 = (Dali::TypeInfo *)jarg1;
18973   arg2 = (Dali::Property::Index)jarg2;
18974   {
18975     try {
18976       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18977     } catch (std::out_of_range& e) {
18978       {
18979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18980       };
18981     } catch (std::exception& e) {
18982       {
18983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18984       };
18985     } catch (...) {
18986       {
18987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18988       };
18989     }
18990   }
18991   jresult = SWIG_csharp_string_callback(result->c_str());
18992   return jresult;
18993 }
18994
18995
18996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
18997   void * jresult ;
18998   Dali::TypeRegistry result;
18999
19000   {
19001     try {
19002       result = Dali::TypeRegistry::Get();
19003     } catch (std::out_of_range& e) {
19004       {
19005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19006       };
19007     } catch (std::exception& e) {
19008       {
19009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19010       };
19011     } catch (...) {
19012       {
19013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19014       };
19015     }
19016   }
19017   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19018   return jresult;
19019 }
19020
19021
19022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19023   void * jresult ;
19024   Dali::TypeRegistry *result = 0 ;
19025
19026   {
19027     try {
19028       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19029     } catch (std::out_of_range& e) {
19030       {
19031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19032       };
19033     } catch (std::exception& e) {
19034       {
19035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19036       };
19037     } catch (...) {
19038       {
19039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19040       };
19041     }
19042   }
19043   jresult = (void *)result;
19044   return jresult;
19045 }
19046
19047
19048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19049   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19050
19051   arg1 = (Dali::TypeRegistry *)jarg1;
19052   {
19053     try {
19054       delete arg1;
19055     } catch (std::out_of_range& e) {
19056       {
19057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19058       };
19059     } catch (std::exception& e) {
19060       {
19061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19062       };
19063     } catch (...) {
19064       {
19065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19066       };
19067     }
19068   }
19069 }
19070
19071
19072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19073   void * jresult ;
19074   Dali::TypeRegistry *arg1 = 0 ;
19075   Dali::TypeRegistry *result = 0 ;
19076
19077   arg1 = (Dali::TypeRegistry *)jarg1;
19078   if (!arg1) {
19079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19080     return 0;
19081   }
19082   {
19083     try {
19084       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19085     } catch (std::out_of_range& e) {
19086       {
19087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19088       };
19089     } catch (std::exception& e) {
19090       {
19091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19092       };
19093     } catch (...) {
19094       {
19095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19096       };
19097     }
19098   }
19099   jresult = (void *)result;
19100   return jresult;
19101 }
19102
19103
19104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19105   void * jresult ;
19106   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19107   Dali::TypeRegistry *arg2 = 0 ;
19108   Dali::TypeRegistry *result = 0 ;
19109
19110   arg1 = (Dali::TypeRegistry *)jarg1;
19111   arg2 = (Dali::TypeRegistry *)jarg2;
19112   if (!arg2) {
19113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19114     return 0;
19115   }
19116   {
19117     try {
19118       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19119     } catch (std::out_of_range& e) {
19120       {
19121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19122       };
19123     } catch (std::exception& e) {
19124       {
19125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19126       };
19127     } catch (...) {
19128       {
19129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19130       };
19131     }
19132   }
19133   jresult = (void *)result;
19134   return jresult;
19135 }
19136
19137
19138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19139   void * jresult ;
19140   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19141   std::string *arg2 = 0 ;
19142   Dali::TypeInfo result;
19143
19144   arg1 = (Dali::TypeRegistry *)jarg1;
19145   if (!jarg2) {
19146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19147     return 0;
19148   }
19149   std::string arg2_str(jarg2);
19150   arg2 = &arg2_str;
19151   {
19152     try {
19153       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19154     } catch (std::out_of_range& e) {
19155       {
19156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19157       };
19158     } catch (std::exception& e) {
19159       {
19160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19161       };
19162     } catch (...) {
19163       {
19164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19165       };
19166     }
19167   }
19168   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19169
19170   //argout typemap for const std::string&
19171
19172   return jresult;
19173 }
19174
19175
19176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19177   void * jresult ;
19178   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19179   std::type_info *arg2 = 0 ;
19180   Dali::TypeInfo result;
19181
19182   arg1 = (Dali::TypeRegistry *)jarg1;
19183   arg2 = (std::type_info *)jarg2;
19184   if (!arg2) {
19185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19186     return 0;
19187   }
19188   {
19189     try {
19190       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19191     } catch (std::out_of_range& e) {
19192       {
19193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19194       };
19195     } catch (std::exception& e) {
19196       {
19197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19198       };
19199     } catch (...) {
19200       {
19201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19202       };
19203     }
19204   }
19205   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19206   return jresult;
19207 }
19208
19209
19210 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19211   unsigned long jresult ;
19212   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19213   size_t result;
19214
19215   arg1 = (Dali::TypeRegistry *)jarg1;
19216   {
19217     try {
19218       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19219     } catch (std::out_of_range& e) {
19220       {
19221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19222       };
19223     } catch (std::exception& e) {
19224       {
19225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19226       };
19227     } catch (...) {
19228       {
19229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19230       };
19231     }
19232   }
19233   jresult = (unsigned long)result;
19234   return jresult;
19235 }
19236
19237
19238 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19239   char * jresult ;
19240   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19241   size_t arg2 ;
19242   std::string result;
19243
19244   arg1 = (Dali::TypeRegistry *)jarg1;
19245   arg2 = (size_t)jarg2;
19246   {
19247     try {
19248       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19249     } catch (std::out_of_range& e) {
19250       {
19251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19252       };
19253     } catch (std::exception& e) {
19254       {
19255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19256       };
19257     } catch (...) {
19258       {
19259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19260       };
19261     }
19262   }
19263   jresult = SWIG_csharp_string_callback((&result)->c_str());
19264   return jresult;
19265 }
19266
19267
19268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19269   void * jresult ;
19270   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19271   Dali::TypeRegistry *result = 0 ;
19272
19273   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19274   {
19275     try {
19276       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19277     } catch (std::out_of_range& e) {
19278       {
19279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19280       };
19281     } catch (std::exception& e) {
19282       {
19283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19284       };
19285     } catch (...) {
19286       {
19287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19288       };
19289     }
19290   }
19291   jresult = (void *)result;
19292   return jresult;
19293 }
19294
19295
19296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19297   void * jresult ;
19298   std::type_info *arg1 = 0 ;
19299   std::type_info *arg2 = 0 ;
19300   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19301   Dali::TypeRegistration *result = 0 ;
19302
19303   arg1 = (std::type_info *)jarg1;
19304   if (!arg1) {
19305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19306     return 0;
19307   }
19308   arg2 = (std::type_info *)jarg2;
19309   if (!arg2) {
19310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19311     return 0;
19312   }
19313   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19314   {
19315     try {
19316       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19317     } catch (std::out_of_range& e) {
19318       {
19319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19320       };
19321     } catch (std::exception& e) {
19322       {
19323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19324       };
19325     } catch (...) {
19326       {
19327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19328       };
19329     }
19330   }
19331   jresult = (void *)result;
19332   return jresult;
19333 }
19334
19335
19336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19337   void * jresult ;
19338   std::type_info *arg1 = 0 ;
19339   std::type_info *arg2 = 0 ;
19340   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19341   bool arg4 ;
19342   Dali::TypeRegistration *result = 0 ;
19343
19344   arg1 = (std::type_info *)jarg1;
19345   if (!arg1) {
19346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19347     return 0;
19348   }
19349   arg2 = (std::type_info *)jarg2;
19350   if (!arg2) {
19351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19352     return 0;
19353   }
19354   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19355   arg4 = jarg4 ? true : false;
19356   {
19357     try {
19358       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19359     } catch (std::out_of_range& e) {
19360       {
19361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19362       };
19363     } catch (std::exception& e) {
19364       {
19365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19366       };
19367     } catch (...) {
19368       {
19369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19370       };
19371     }
19372   }
19373   jresult = (void *)result;
19374   return jresult;
19375 }
19376
19377
19378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19379   void * jresult ;
19380   std::string *arg1 = 0 ;
19381   std::type_info *arg2 = 0 ;
19382   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19383   Dali::TypeRegistration *result = 0 ;
19384
19385   if (!jarg1) {
19386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19387     return 0;
19388   }
19389   std::string arg1_str(jarg1);
19390   arg1 = &arg1_str;
19391   arg2 = (std::type_info *)jarg2;
19392   if (!arg2) {
19393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19394     return 0;
19395   }
19396   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19397   {
19398     try {
19399       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19400     } catch (std::out_of_range& e) {
19401       {
19402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19403       };
19404     } catch (std::exception& e) {
19405       {
19406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19407       };
19408     } catch (...) {
19409       {
19410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19411       };
19412     }
19413   }
19414   jresult = (void *)result;
19415
19416   //argout typemap for const std::string&
19417
19418   return jresult;
19419 }
19420
19421
19422 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19423   char * jresult ;
19424   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19425   std::string result;
19426
19427   arg1 = (Dali::TypeRegistration *)jarg1;
19428   {
19429     try {
19430       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19431     } catch (std::out_of_range& e) {
19432       {
19433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19434       };
19435     } catch (std::exception& e) {
19436       {
19437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19438       };
19439     } catch (...) {
19440       {
19441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19442       };
19443     }
19444   }
19445   jresult = SWIG_csharp_string_callback((&result)->c_str());
19446   return jresult;
19447 }
19448
19449
19450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19451   std::string *arg1 = 0 ;
19452   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19453
19454   if (!jarg1) {
19455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19456     return ;
19457   }
19458   std::string arg1_str(jarg1);
19459   arg1 = &arg1_str;
19460   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19461   {
19462     try {
19463       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19464     } catch (std::out_of_range& e) {
19465       {
19466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19467       };
19468     } catch (std::exception& e) {
19469       {
19470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19471       };
19472     } catch (...) {
19473       {
19474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19475       };
19476     }
19477   }
19478
19479   //argout typemap for const std::string&
19480
19481 }
19482
19483
19484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19485   std::string *arg1 = 0 ;
19486   std::string *arg2 = 0 ;
19487   int arg3 ;
19488   Dali::Property::Type arg4 ;
19489   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19490   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19491
19492   if (!jarg1) {
19493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19494     return ;
19495   }
19496   std::string arg1_str(jarg1);
19497   arg1 = &arg1_str;
19498   if (!jarg2) {
19499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19500     return ;
19501   }
19502   std::string arg2_str(jarg2);
19503   arg2 = &arg2_str;
19504   arg3 = (int)jarg3;
19505   arg4 = (Dali::Property::Type)jarg4;
19506   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19507   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19508   {
19509     try {
19510       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19511     } catch (std::out_of_range& e) {
19512       {
19513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19514       };
19515     } catch (std::exception& e) {
19516       {
19517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19518       };
19519     } catch (...) {
19520       {
19521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19522       };
19523     }
19524   }
19525
19526   //argout typemap for const std::string&
19527
19528
19529   //argout typemap for const std::string&
19530
19531 }
19532
19533
19534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19535   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19536
19537   arg1 = (Dali::TypeRegistration *)jarg1;
19538   {
19539     try {
19540       delete arg1;
19541     } catch (std::out_of_range& e) {
19542       {
19543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19544       };
19545     } catch (std::exception& e) {
19546       {
19547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19548       };
19549     } catch (...) {
19550       {
19551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19552       };
19553     }
19554   }
19555 }
19556
19557
19558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19559   void * jresult ;
19560   Dali::TypeRegistration *arg1 = 0 ;
19561   std::string *arg2 = 0 ;
19562   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19563   Dali::SignalConnectorType *result = 0 ;
19564
19565   arg1 = (Dali::TypeRegistration *)jarg1;
19566   if (!arg1) {
19567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19568     return 0;
19569   }
19570   if (!jarg2) {
19571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19572     return 0;
19573   }
19574   std::string arg2_str(jarg2);
19575   arg2 = &arg2_str;
19576   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19577   {
19578     try {
19579       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19580     } catch (std::out_of_range& e) {
19581       {
19582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19583       };
19584     } catch (std::exception& e) {
19585       {
19586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19587       };
19588     } catch (...) {
19589       {
19590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19591       };
19592     }
19593   }
19594   jresult = (void *)result;
19595
19596   //argout typemap for const std::string&
19597
19598   return jresult;
19599 }
19600
19601
19602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19603   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19604
19605   arg1 = (Dali::SignalConnectorType *)jarg1;
19606   {
19607     try {
19608       delete arg1;
19609     } catch (std::out_of_range& e) {
19610       {
19611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19612       };
19613     } catch (std::exception& e) {
19614       {
19615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19616       };
19617     } catch (...) {
19618       {
19619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19620       };
19621     }
19622   }
19623 }
19624
19625
19626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19627   void * jresult ;
19628   Dali::TypeRegistration *arg1 = 0 ;
19629   std::string *arg2 = 0 ;
19630   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19631   Dali::TypeAction *result = 0 ;
19632
19633   arg1 = (Dali::TypeRegistration *)jarg1;
19634   if (!arg1) {
19635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19636     return 0;
19637   }
19638   if (!jarg2) {
19639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19640     return 0;
19641   }
19642   std::string arg2_str(jarg2);
19643   arg2 = &arg2_str;
19644   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19645   {
19646     try {
19647       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19648     } catch (std::out_of_range& e) {
19649       {
19650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19651       };
19652     } catch (std::exception& e) {
19653       {
19654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19655       };
19656     } catch (...) {
19657       {
19658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19659       };
19660     }
19661   }
19662   jresult = (void *)result;
19663
19664   //argout typemap for const std::string&
19665
19666   return jresult;
19667 }
19668
19669
19670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19671   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19672
19673   arg1 = (Dali::TypeAction *)jarg1;
19674   {
19675     try {
19676       delete arg1;
19677     } catch (std::out_of_range& e) {
19678       {
19679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19680       };
19681     } catch (std::exception& e) {
19682       {
19683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19684       };
19685     } catch (...) {
19686       {
19687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19688       };
19689     }
19690   }
19691 }
19692
19693
19694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19695   void * jresult ;
19696   Dali::TypeRegistration *arg1 = 0 ;
19697   std::string *arg2 = 0 ;
19698   Dali::Property::Index arg3 ;
19699   Dali::Property::Type arg4 ;
19700   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19701   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19702   Dali::PropertyRegistration *result = 0 ;
19703
19704   arg1 = (Dali::TypeRegistration *)jarg1;
19705   if (!arg1) {
19706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19707     return 0;
19708   }
19709   if (!jarg2) {
19710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19711     return 0;
19712   }
19713   std::string arg2_str(jarg2);
19714   arg2 = &arg2_str;
19715   arg3 = (Dali::Property::Index)jarg3;
19716   arg4 = (Dali::Property::Type)jarg4;
19717   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19718   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19719   {
19720     try {
19721       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19722     } catch (std::out_of_range& e) {
19723       {
19724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19725       };
19726     } catch (std::exception& e) {
19727       {
19728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19729       };
19730     } catch (...) {
19731       {
19732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19733       };
19734     }
19735   }
19736   jresult = (void *)result;
19737
19738   //argout typemap for const std::string&
19739
19740   return jresult;
19741 }
19742
19743
19744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19745   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19746
19747   arg1 = (Dali::PropertyRegistration *)jarg1;
19748   {
19749     try {
19750       delete arg1;
19751     } catch (std::out_of_range& e) {
19752       {
19753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19754       };
19755     } catch (std::exception& e) {
19756       {
19757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19758       };
19759     } catch (...) {
19760       {
19761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19762       };
19763     }
19764   }
19765 }
19766
19767
19768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19769   void * jresult ;
19770   Dali::TypeRegistration *arg1 = 0 ;
19771   std::string *arg2 = 0 ;
19772   Dali::Property::Index arg3 ;
19773   Dali::Property::Type arg4 ;
19774   Dali::AnimatablePropertyRegistration *result = 0 ;
19775
19776   arg1 = (Dali::TypeRegistration *)jarg1;
19777   if (!arg1) {
19778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19779     return 0;
19780   }
19781   if (!jarg2) {
19782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19783     return 0;
19784   }
19785   std::string arg2_str(jarg2);
19786   arg2 = &arg2_str;
19787   arg3 = (Dali::Property::Index)jarg3;
19788   arg4 = (Dali::Property::Type)jarg4;
19789   {
19790     try {
19791       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19792     } catch (std::out_of_range& e) {
19793       {
19794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19795       };
19796     } catch (std::exception& e) {
19797       {
19798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19799       };
19800     } catch (...) {
19801       {
19802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19803       };
19804     }
19805   }
19806   jresult = (void *)result;
19807
19808   //argout typemap for const std::string&
19809
19810   return jresult;
19811 }
19812
19813
19814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19815   void * jresult ;
19816   Dali::TypeRegistration *arg1 = 0 ;
19817   std::string *arg2 = 0 ;
19818   Dali::Property::Index arg3 ;
19819   Dali::Property::Value *arg4 = 0 ;
19820   Dali::AnimatablePropertyRegistration *result = 0 ;
19821
19822   arg1 = (Dali::TypeRegistration *)jarg1;
19823   if (!arg1) {
19824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19825     return 0;
19826   }
19827   if (!jarg2) {
19828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19829     return 0;
19830   }
19831   std::string arg2_str(jarg2);
19832   arg2 = &arg2_str;
19833   arg3 = (Dali::Property::Index)jarg3;
19834   arg4 = (Dali::Property::Value *)jarg4;
19835   if (!arg4) {
19836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19837     return 0;
19838   }
19839   {
19840     try {
19841       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19842     } catch (std::out_of_range& e) {
19843       {
19844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19845       };
19846     } catch (std::exception& e) {
19847       {
19848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19849       };
19850     } catch (...) {
19851       {
19852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19853       };
19854     }
19855   }
19856   jresult = (void *)result;
19857
19858   //argout typemap for const std::string&
19859
19860   return jresult;
19861 }
19862
19863
19864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19865   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19866
19867   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19868   {
19869     try {
19870       delete arg1;
19871     } catch (std::out_of_range& e) {
19872       {
19873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19874       };
19875     } catch (std::exception& e) {
19876       {
19877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19878       };
19879     } catch (...) {
19880       {
19881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19882       };
19883     }
19884   }
19885 }
19886
19887
19888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19889   void * jresult ;
19890   Dali::TypeRegistration *arg1 = 0 ;
19891   std::string *arg2 = 0 ;
19892   Dali::Property::Index arg3 ;
19893   Dali::Property::Index arg4 ;
19894   unsigned int arg5 ;
19895   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19896
19897   arg1 = (Dali::TypeRegistration *)jarg1;
19898   if (!arg1) {
19899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19900     return 0;
19901   }
19902   if (!jarg2) {
19903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19904     return 0;
19905   }
19906   std::string arg2_str(jarg2);
19907   arg2 = &arg2_str;
19908   arg3 = (Dali::Property::Index)jarg3;
19909   arg4 = (Dali::Property::Index)jarg4;
19910   arg5 = (unsigned int)jarg5;
19911   {
19912     try {
19913       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19914     } catch (std::out_of_range& e) {
19915       {
19916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19917       };
19918     } catch (std::exception& e) {
19919       {
19920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19921       };
19922     } catch (...) {
19923       {
19924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19925       };
19926     }
19927   }
19928   jresult = (void *)result;
19929
19930   //argout typemap for const std::string&
19931
19932   return jresult;
19933 }
19934
19935
19936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19937   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19938
19939   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19940   {
19941     try {
19942       delete arg1;
19943     } catch (std::out_of_range& e) {
19944       {
19945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19946       };
19947     } catch (std::exception& e) {
19948       {
19949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19950       };
19951     } catch (...) {
19952       {
19953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19954       };
19955     }
19956   }
19957 }
19958
19959
19960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19961   void * jresult ;
19962   Dali::TypeRegistration *arg1 = 0 ;
19963   std::string *arg2 = 0 ;
19964   Dali::Property::Index arg3 ;
19965   Dali::Property::Type arg4 ;
19966   Dali::ChildPropertyRegistration *result = 0 ;
19967
19968   arg1 = (Dali::TypeRegistration *)jarg1;
19969   if (!arg1) {
19970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19971     return 0;
19972   }
19973   if (!jarg2) {
19974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19975     return 0;
19976   }
19977   std::string arg2_str(jarg2);
19978   arg2 = &arg2_str;
19979   arg3 = (Dali::Property::Index)jarg3;
19980   arg4 = (Dali::Property::Type)jarg4;
19981   {
19982     try {
19983       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19984     } catch (std::out_of_range& e) {
19985       {
19986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19987       };
19988     } catch (std::exception& e) {
19989       {
19990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19991       };
19992     } catch (...) {
19993       {
19994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19995       };
19996     }
19997   }
19998   jresult = (void *)result;
19999
20000   //argout typemap for const std::string&
20001
20002   return jresult;
20003 }
20004
20005
20006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20007   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20008
20009   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20010   {
20011     try {
20012       delete arg1;
20013     } catch (std::out_of_range& e) {
20014       {
20015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20016       };
20017     } catch (std::exception& e) {
20018       {
20019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20020       };
20021     } catch (...) {
20022       {
20023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20024       };
20025     }
20026   }
20027 }
20028
20029
20030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20031   unsigned int jresult ;
20032   std::string *arg1 = 0 ;
20033   std::type_info *arg2 = 0 ;
20034   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20035   bool result;
20036
20037   if (!jarg1) {
20038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20039     return 0;
20040   }
20041   std::string arg1_str(jarg1);
20042   arg1 = &arg1_str;
20043   arg2 = (std::type_info *)jarg2;
20044   if (!arg2) {
20045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20046     return 0;
20047   }
20048   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20049   {
20050     try {
20051       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20052     } catch (std::out_of_range& e) {
20053       {
20054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20055       };
20056     } catch (std::exception& e) {
20057       {
20058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20059       };
20060     } catch (...) {
20061       {
20062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20063       };
20064     }
20065   }
20066   jresult = result;
20067
20068   //argout typemap for const std::string&
20069
20070   return jresult;
20071 }
20072
20073
20074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20075   unsigned int jresult ;
20076   std::string *arg1 = 0 ;
20077   std::string *arg2 = 0 ;
20078   Dali::Property::Index arg3 ;
20079   Dali::Property::Type arg4 ;
20080   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20081   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20082   bool result;
20083
20084   if (!jarg1) {
20085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20086     return 0;
20087   }
20088   std::string arg1_str(jarg1);
20089   arg1 = &arg1_str;
20090   if (!jarg2) {
20091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20092     return 0;
20093   }
20094   std::string arg2_str(jarg2);
20095   arg2 = &arg2_str;
20096   arg3 = (Dali::Property::Index)jarg3;
20097   arg4 = (Dali::Property::Type)jarg4;
20098   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20099   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20100   {
20101     try {
20102       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20103     } catch (std::out_of_range& e) {
20104       {
20105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20106       };
20107     } catch (std::exception& e) {
20108       {
20109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20110       };
20111     } catch (...) {
20112       {
20113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20114       };
20115     }
20116   }
20117   jresult = result;
20118
20119   //argout typemap for const std::string&
20120
20121
20122   //argout typemap for const std::string&
20123
20124   return jresult;
20125 }
20126
20127
20128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20129   float jresult ;
20130   float result;
20131
20132   result = (float)(float)Dali::ParentOrigin::TOP;
20133   jresult = result;
20134   return jresult;
20135 }
20136
20137
20138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20139   float jresult ;
20140   float result;
20141
20142   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20143   jresult = result;
20144   return jresult;
20145 }
20146
20147
20148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20149   float jresult ;
20150   float result;
20151
20152   result = (float)(float)Dali::ParentOrigin::LEFT;
20153   jresult = result;
20154   return jresult;
20155 }
20156
20157
20158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20159   float jresult ;
20160   float result;
20161
20162   result = (float)(float)Dali::ParentOrigin::RIGHT;
20163   jresult = result;
20164   return jresult;
20165 }
20166
20167
20168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20169   float jresult ;
20170   float result;
20171
20172   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20173   jresult = result;
20174   return jresult;
20175 }
20176
20177
20178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20179   void * jresult ;
20180   Dali::Vector3 *result = 0 ;
20181
20182   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20183   jresult = (void *)result;
20184   return jresult;
20185 }
20186
20187
20188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20189   void * jresult ;
20190   Dali::Vector3 *result = 0 ;
20191
20192   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20193   jresult = (void *)result;
20194   return jresult;
20195 }
20196
20197
20198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20199   void * jresult ;
20200   Dali::Vector3 *result = 0 ;
20201
20202   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20203   jresult = (void *)result;
20204   return jresult;
20205 }
20206
20207
20208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20209   void * jresult ;
20210   Dali::Vector3 *result = 0 ;
20211
20212   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20213   jresult = (void *)result;
20214   return jresult;
20215 }
20216
20217
20218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20219   void * jresult ;
20220   Dali::Vector3 *result = 0 ;
20221
20222   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20223   jresult = (void *)result;
20224   return jresult;
20225 }
20226
20227
20228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20229   void * jresult ;
20230   Dali::Vector3 *result = 0 ;
20231
20232   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20233   jresult = (void *)result;
20234   return jresult;
20235 }
20236
20237
20238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20239   void * jresult ;
20240   Dali::Vector3 *result = 0 ;
20241
20242   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20243   jresult = (void *)result;
20244   return jresult;
20245 }
20246
20247
20248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20249   void * jresult ;
20250   Dali::Vector3 *result = 0 ;
20251
20252   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20253   jresult = (void *)result;
20254   return jresult;
20255 }
20256
20257
20258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20259   void * jresult ;
20260   Dali::Vector3 *result = 0 ;
20261
20262   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20263   jresult = (void *)result;
20264   return jresult;
20265 }
20266
20267
20268 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20269   float jresult ;
20270   float result;
20271
20272   result = (float)(float)Dali::AnchorPoint::TOP;
20273   jresult = result;
20274   return jresult;
20275 }
20276
20277
20278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20279   float jresult ;
20280   float result;
20281
20282   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20283   jresult = result;
20284   return jresult;
20285 }
20286
20287
20288 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20289   float jresult ;
20290   float result;
20291
20292   result = (float)(float)Dali::AnchorPoint::LEFT;
20293   jresult = result;
20294   return jresult;
20295 }
20296
20297
20298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20299   float jresult ;
20300   float result;
20301
20302   result = (float)(float)Dali::AnchorPoint::RIGHT;
20303   jresult = result;
20304   return jresult;
20305 }
20306
20307
20308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20309   float jresult ;
20310   float result;
20311
20312   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20313   jresult = result;
20314   return jresult;
20315 }
20316
20317
20318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20319   void * jresult ;
20320   Dali::Vector3 *result = 0 ;
20321
20322   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20323   jresult = (void *)result;
20324   return jresult;
20325 }
20326
20327
20328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20329   void * jresult ;
20330   Dali::Vector3 *result = 0 ;
20331
20332   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20333   jresult = (void *)result;
20334   return jresult;
20335 }
20336
20337
20338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20339   void * jresult ;
20340   Dali::Vector3 *result = 0 ;
20341
20342   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20343   jresult = (void *)result;
20344   return jresult;
20345 }
20346
20347
20348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20349   void * jresult ;
20350   Dali::Vector3 *result = 0 ;
20351
20352   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20353   jresult = (void *)result;
20354   return jresult;
20355 }
20356
20357
20358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20359   void * jresult ;
20360   Dali::Vector3 *result = 0 ;
20361
20362   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20363   jresult = (void *)result;
20364   return jresult;
20365 }
20366
20367
20368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20369   void * jresult ;
20370   Dali::Vector3 *result = 0 ;
20371
20372   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20373   jresult = (void *)result;
20374   return jresult;
20375 }
20376
20377
20378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20379   void * jresult ;
20380   Dali::Vector3 *result = 0 ;
20381
20382   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20383   jresult = (void *)result;
20384   return jresult;
20385 }
20386
20387
20388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20389   void * jresult ;
20390   Dali::Vector3 *result = 0 ;
20391
20392   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20393   jresult = (void *)result;
20394   return jresult;
20395 }
20396
20397
20398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20399   void * jresult ;
20400   Dali::Vector3 *result = 0 ;
20401
20402   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20403   jresult = (void *)result;
20404   return jresult;
20405 }
20406
20407
20408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20409   void * jresult ;
20410   Dali::Vector4 *result = 0 ;
20411
20412   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20413   jresult = (void *)result;
20414   return jresult;
20415 }
20416
20417
20418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20419   void * jresult ;
20420   Dali::Vector4 *result = 0 ;
20421
20422   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20423   jresult = (void *)result;
20424   return jresult;
20425 }
20426
20427
20428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20429   void * jresult ;
20430   Dali::Vector4 *result = 0 ;
20431
20432   result = (Dali::Vector4 *)&Dali::Color::RED;
20433   jresult = (void *)result;
20434   return jresult;
20435 }
20436
20437
20438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20439   void * jresult ;
20440   Dali::Vector4 *result = 0 ;
20441
20442   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20443   jresult = (void *)result;
20444   return jresult;
20445 }
20446
20447
20448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20449   void * jresult ;
20450   Dali::Vector4 *result = 0 ;
20451
20452   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20453   jresult = (void *)result;
20454   return jresult;
20455 }
20456
20457
20458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20459   void * jresult ;
20460   Dali::Vector4 *result = 0 ;
20461
20462   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20463   jresult = (void *)result;
20464   return jresult;
20465 }
20466
20467
20468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20469   void * jresult ;
20470   Dali::Vector4 *result = 0 ;
20471
20472   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20473   jresult = (void *)result;
20474   return jresult;
20475 }
20476
20477
20478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20479   void * jresult ;
20480   Dali::Vector4 *result = 0 ;
20481
20482   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20483   jresult = (void *)result;
20484   return jresult;
20485 }
20486
20487
20488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20489   void * jresult ;
20490   Dali::Vector4 *result = 0 ;
20491
20492   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20493   jresult = (void *)result;
20494   return jresult;
20495 }
20496
20497
20498 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20499   float jresult ;
20500   float result;
20501
20502   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20503   jresult = result;
20504   return jresult;
20505 }
20506
20507
20508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20509   float jresult ;
20510   float result;
20511
20512   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20513   jresult = result;
20514   return jresult;
20515 }
20516
20517
20518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20519   float jresult ;
20520   float result;
20521
20522   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20523   jresult = result;
20524   return jresult;
20525 }
20526
20527
20528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20529   float jresult ;
20530   float result;
20531
20532   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20533   jresult = result;
20534   return jresult;
20535 }
20536
20537
20538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20539   float jresult ;
20540   float result;
20541
20542   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20543   jresult = result;
20544   return jresult;
20545 }
20546
20547
20548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20549   float jresult ;
20550   float result;
20551
20552   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20553   jresult = result;
20554   return jresult;
20555 }
20556
20557
20558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20559   float jresult ;
20560   float result;
20561
20562   result = (float)(float)Dali::Math::PI;
20563   jresult = result;
20564   return jresult;
20565 }
20566
20567
20568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20569   float jresult ;
20570   float result;
20571
20572   result = (float)(float)Dali::Math::PI_2;
20573   jresult = result;
20574   return jresult;
20575 }
20576
20577
20578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20579   float jresult ;
20580   float result;
20581
20582   result = (float)(float)Dali::Math::PI_4;
20583   jresult = result;
20584   return jresult;
20585 }
20586
20587
20588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20589   float jresult ;
20590   float result;
20591
20592   result = (float)(float)Dali::Math::PI_OVER_180;
20593   jresult = result;
20594   return jresult;
20595 }
20596
20597
20598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20599   float jresult ;
20600   float result;
20601
20602   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20603   jresult = result;
20604   return jresult;
20605 }
20606
20607
20608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20609   int jresult ;
20610   Dali::ResizePolicy::Type result;
20611
20612   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20613   jresult = (int)result;
20614   return jresult;
20615 }
20616
20617
20618 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20619   unsigned long jresult ;
20620   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20621   Dali::VectorBase::SizeType result;
20622
20623   arg1 = (Dali::VectorBase *)jarg1;
20624   {
20625     try {
20626       result = ((Dali::VectorBase const *)arg1)->Count();
20627     } catch (std::out_of_range& e) {
20628       {
20629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20630       };
20631     } catch (std::exception& e) {
20632       {
20633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20634       };
20635     } catch (...) {
20636       {
20637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20638       };
20639     }
20640   }
20641   jresult = (unsigned long)result;
20642   return jresult;
20643 }
20644
20645
20646 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20647   unsigned long jresult ;
20648   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20649   Dali::VectorBase::SizeType result;
20650
20651   arg1 = (Dali::VectorBase *)jarg1;
20652   {
20653     try {
20654       result = ((Dali::VectorBase const *)arg1)->Size();
20655     } catch (std::out_of_range& e) {
20656       {
20657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20658       };
20659     } catch (std::exception& e) {
20660       {
20661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20662       };
20663     } catch (...) {
20664       {
20665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20666       };
20667     }
20668   }
20669   jresult = (unsigned long)result;
20670   return jresult;
20671 }
20672
20673
20674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20675   unsigned int jresult ;
20676   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20677   bool result;
20678
20679   arg1 = (Dali::VectorBase *)jarg1;
20680   {
20681     try {
20682       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20683     } catch (std::out_of_range& e) {
20684       {
20685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20686       };
20687     } catch (std::exception& e) {
20688       {
20689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20690       };
20691     } catch (...) {
20692       {
20693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20694       };
20695     }
20696   }
20697   jresult = result;
20698   return jresult;
20699 }
20700
20701
20702 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20703   unsigned long jresult ;
20704   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20705   Dali::VectorBase::SizeType result;
20706
20707   arg1 = (Dali::VectorBase *)jarg1;
20708   {
20709     try {
20710       result = ((Dali::VectorBase const *)arg1)->Capacity();
20711     } catch (std::out_of_range& e) {
20712       {
20713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20714       };
20715     } catch (std::exception& e) {
20716       {
20717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20718       };
20719     } catch (...) {
20720       {
20721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20722       };
20723     }
20724   }
20725   jresult = (unsigned long)result;
20726   return jresult;
20727 }
20728
20729
20730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20731   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20732
20733   arg1 = (Dali::VectorBase *)jarg1;
20734   {
20735     try {
20736       (arg1)->Release();
20737     } catch (std::out_of_range& e) {
20738       {
20739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20740       };
20741     } catch (std::exception& e) {
20742       {
20743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20744       };
20745     } catch (...) {
20746       {
20747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20748       };
20749     }
20750   }
20751 }
20752
20753
20754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20755   void * jresult ;
20756   Dali::Image *result = 0 ;
20757
20758   {
20759     try {
20760       result = (Dali::Image *)new Dali::Image();
20761     } catch (std::out_of_range& e) {
20762       {
20763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20764       };
20765     } catch (std::exception& e) {
20766       {
20767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20768       };
20769     } catch (...) {
20770       {
20771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20772       };
20773     }
20774   }
20775   jresult = (void *)result;
20776   return jresult;
20777 }
20778
20779
20780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20781   Dali::Image *arg1 = (Dali::Image *) 0 ;
20782
20783   arg1 = (Dali::Image *)jarg1;
20784   {
20785     try {
20786       delete arg1;
20787     } catch (std::out_of_range& e) {
20788       {
20789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20790       };
20791     } catch (std::exception& e) {
20792       {
20793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20794       };
20795     } catch (...) {
20796       {
20797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20798       };
20799     }
20800   }
20801 }
20802
20803
20804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20805   void * jresult ;
20806   Dali::Image *arg1 = 0 ;
20807   Dali::Image *result = 0 ;
20808
20809   arg1 = (Dali::Image *)jarg1;
20810   if (!arg1) {
20811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20812     return 0;
20813   }
20814   {
20815     try {
20816       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20817     } catch (std::out_of_range& e) {
20818       {
20819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20820       };
20821     } catch (std::exception& e) {
20822       {
20823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20824       };
20825     } catch (...) {
20826       {
20827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20828       };
20829     }
20830   }
20831   jresult = (void *)result;
20832   return jresult;
20833 }
20834
20835
20836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20837   void * jresult ;
20838   Dali::Image *arg1 = (Dali::Image *) 0 ;
20839   Dali::Image *arg2 = 0 ;
20840   Dali::Image *result = 0 ;
20841
20842   arg1 = (Dali::Image *)jarg1;
20843   arg2 = (Dali::Image *)jarg2;
20844   if (!arg2) {
20845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20846     return 0;
20847   }
20848   {
20849     try {
20850       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20851     } catch (std::out_of_range& e) {
20852       {
20853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20854       };
20855     } catch (std::exception& e) {
20856       {
20857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20858       };
20859     } catch (...) {
20860       {
20861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20862       };
20863     }
20864   }
20865   jresult = (void *)result;
20866   return jresult;
20867 }
20868
20869
20870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20871   void * jresult ;
20872   Dali::BaseHandle arg1 ;
20873   Dali::BaseHandle *argp1 ;
20874   Dali::Image result;
20875
20876   argp1 = (Dali::BaseHandle *)jarg1;
20877   if (!argp1) {
20878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20879     return 0;
20880   }
20881   arg1 = *argp1;
20882   {
20883     try {
20884       result = Dali::Image::DownCast(arg1);
20885     } catch (std::out_of_range& e) {
20886       {
20887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20888       };
20889     } catch (std::exception& e) {
20890       {
20891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20892       };
20893     } catch (...) {
20894       {
20895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20896       };
20897     }
20898   }
20899   jresult = new Dali::Image((const Dali::Image &)result);
20900   return jresult;
20901 }
20902
20903
20904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20905   unsigned int jresult ;
20906   Dali::Image *arg1 = (Dali::Image *) 0 ;
20907   unsigned int result;
20908
20909   arg1 = (Dali::Image *)jarg1;
20910   {
20911     try {
20912       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20913     } catch (std::out_of_range& e) {
20914       {
20915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20916       };
20917     } catch (std::exception& e) {
20918       {
20919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20920       };
20921     } catch (...) {
20922       {
20923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20924       };
20925     }
20926   }
20927   jresult = result;
20928   return jresult;
20929 }
20930
20931
20932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20933   unsigned int jresult ;
20934   Dali::Image *arg1 = (Dali::Image *) 0 ;
20935   unsigned int result;
20936
20937   arg1 = (Dali::Image *)jarg1;
20938   {
20939     try {
20940       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20941     } catch (std::out_of_range& e) {
20942       {
20943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20944       };
20945     } catch (std::exception& e) {
20946       {
20947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20948       };
20949     } catch (...) {
20950       {
20951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20952       };
20953     }
20954   }
20955   jresult = result;
20956   return jresult;
20957 }
20958
20959
20960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20961   void * jresult ;
20962   Dali::Image *arg1 = (Dali::Image *) 0 ;
20963   Dali::Image::ImageSignalType *result = 0 ;
20964
20965   arg1 = (Dali::Image *)jarg1;
20966   {
20967     try {
20968       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20969     } catch (std::out_of_range& e) {
20970       {
20971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20972       };
20973     } catch (std::exception& e) {
20974       {
20975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20976       };
20977     } catch (...) {
20978       {
20979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20980       };
20981     }
20982   }
20983   jresult = (void *)result;
20984   return jresult;
20985 }
20986
20987
20988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
20989   int jresult ;
20990   Dali::Pixel::Format result;
20991
20992   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
20993   jresult = (int)result;
20994   return jresult;
20995 }
20996
20997
20998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
20999   int jresult ;
21000   Dali::Pixel::Format result;
21001
21002   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21003   jresult = (int)result;
21004   return jresult;
21005 }
21006
21007
21008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21009   unsigned int jresult ;
21010   Dali::Pixel::Format arg1 ;
21011   bool result;
21012
21013   arg1 = (Dali::Pixel::Format)jarg1;
21014   {
21015     try {
21016       result = (bool)Dali::Pixel::HasAlpha(arg1);
21017     } catch (std::out_of_range& e) {
21018       {
21019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21020       };
21021     } catch (std::exception& e) {
21022       {
21023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21024       };
21025     } catch (...) {
21026       {
21027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21028       };
21029     }
21030   }
21031   jresult = result;
21032   return jresult;
21033 }
21034
21035
21036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21037   unsigned int jresult ;
21038   Dali::Pixel::Format arg1 ;
21039   unsigned int result;
21040
21041   arg1 = (Dali::Pixel::Format)jarg1;
21042   {
21043     try {
21044       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21045     } catch (std::out_of_range& e) {
21046       {
21047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21048       };
21049     } catch (std::exception& e) {
21050       {
21051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21052       };
21053     } catch (...) {
21054       {
21055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21056       };
21057     }
21058   }
21059   jresult = result;
21060   return jresult;
21061 }
21062
21063
21064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21065   Dali::Pixel::Format arg1 ;
21066   int *arg2 = 0 ;
21067   int *arg3 = 0 ;
21068
21069   arg1 = (Dali::Pixel::Format)jarg1;
21070   arg2 = (int *)jarg2;
21071   if (!arg2) {
21072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21073     return ;
21074   }
21075   arg3 = (int *)jarg3;
21076   if (!arg3) {
21077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21078     return ;
21079   }
21080   {
21081     try {
21082       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21083     } catch (std::out_of_range& e) {
21084       {
21085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21086       };
21087     } catch (std::exception& e) {
21088       {
21089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21090       };
21091     } catch (...) {
21092       {
21093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21094       };
21095     }
21096   }
21097 }
21098
21099
21100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21101   void * jresult ;
21102   unsigned char *arg1 = (unsigned char *) 0 ;
21103   unsigned int arg2 ;
21104   unsigned int arg3 ;
21105   unsigned int arg4 ;
21106   Dali::Pixel::Format arg5 ;
21107   Dali::PixelData::ReleaseFunction arg6 ;
21108   Dali::PixelData result;
21109
21110   arg1 = jarg1;
21111   arg2 = (unsigned int)jarg2;
21112   arg3 = (unsigned int)jarg3;
21113   arg4 = (unsigned int)jarg4;
21114   arg5 = (Dali::Pixel::Format)jarg5;
21115   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21116   {
21117     try {
21118       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21119     } catch (std::out_of_range& e) {
21120       {
21121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21122       };
21123     } catch (std::exception& e) {
21124       {
21125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21126       };
21127     } catch (...) {
21128       {
21129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21130       };
21131     }
21132   }
21133   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21134
21135
21136   return jresult;
21137 }
21138
21139
21140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21141   void * jresult ;
21142   Dali::PixelData *result = 0 ;
21143
21144   {
21145     try {
21146       result = (Dali::PixelData *)new Dali::PixelData();
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 (...) {
21156       {
21157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21158       };
21159     }
21160   }
21161   jresult = (void *)result;
21162   return jresult;
21163 }
21164
21165
21166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21167   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21168
21169   arg1 = (Dali::PixelData *)jarg1;
21170   {
21171     try {
21172       delete arg1;
21173     } catch (std::out_of_range& e) {
21174       {
21175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21176       };
21177     } catch (std::exception& e) {
21178       {
21179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21180       };
21181     } catch (...) {
21182       {
21183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21184       };
21185     }
21186   }
21187 }
21188
21189
21190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21191   void * jresult ;
21192   Dali::PixelData *arg1 = 0 ;
21193   Dali::PixelData *result = 0 ;
21194
21195   arg1 = (Dali::PixelData *)jarg1;
21196   if (!arg1) {
21197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21198     return 0;
21199   }
21200   {
21201     try {
21202       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21203     } catch (std::out_of_range& e) {
21204       {
21205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21206       };
21207     } catch (std::exception& e) {
21208       {
21209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21210       };
21211     } catch (...) {
21212       {
21213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21214       };
21215     }
21216   }
21217   jresult = (void *)result;
21218   return jresult;
21219 }
21220
21221
21222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21223   void * jresult ;
21224   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21225   Dali::PixelData *arg2 = 0 ;
21226   Dali::PixelData *result = 0 ;
21227
21228   arg1 = (Dali::PixelData *)jarg1;
21229   arg2 = (Dali::PixelData *)jarg2;
21230   if (!arg2) {
21231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21232     return 0;
21233   }
21234   {
21235     try {
21236       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21237     } catch (std::out_of_range& e) {
21238       {
21239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21240       };
21241     } catch (std::exception& e) {
21242       {
21243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21244       };
21245     } catch (...) {
21246       {
21247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21248       };
21249     }
21250   }
21251   jresult = (void *)result;
21252   return jresult;
21253 }
21254
21255
21256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21257   unsigned int jresult ;
21258   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21259   unsigned int result;
21260
21261   arg1 = (Dali::PixelData *)jarg1;
21262   {
21263     try {
21264       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21265     } catch (std::out_of_range& e) {
21266       {
21267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21268       };
21269     } catch (std::exception& e) {
21270       {
21271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21272       };
21273     } catch (...) {
21274       {
21275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21276       };
21277     }
21278   }
21279   jresult = result;
21280   return jresult;
21281 }
21282
21283
21284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21285   unsigned int jresult ;
21286   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21287   unsigned int result;
21288
21289   arg1 = (Dali::PixelData *)jarg1;
21290   {
21291     try {
21292       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21293     } catch (std::out_of_range& e) {
21294       {
21295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21296       };
21297     } catch (std::exception& e) {
21298       {
21299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21300       };
21301     } catch (...) {
21302       {
21303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21304       };
21305     }
21306   }
21307   jresult = result;
21308   return jresult;
21309 }
21310
21311
21312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21313   int jresult ;
21314   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21315   Dali::Pixel::Format result;
21316
21317   arg1 = (Dali::PixelData *)jarg1;
21318   {
21319     try {
21320       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21321     } catch (std::out_of_range& e) {
21322       {
21323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21324       };
21325     } catch (std::exception& e) {
21326       {
21327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21328       };
21329     } catch (...) {
21330       {
21331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21332       };
21333     }
21334   }
21335   jresult = (int)result;
21336   return jresult;
21337 }
21338
21339
21340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21341   unsigned int jresult ;
21342   unsigned int result;
21343
21344   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21345   jresult = result;
21346   return jresult;
21347 }
21348
21349
21350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21351   unsigned int jresult ;
21352   unsigned int result;
21353
21354   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21355   jresult = result;
21356   return jresult;
21357 }
21358
21359
21360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21361   unsigned int jresult ;
21362   unsigned int result;
21363
21364   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21365   jresult = result;
21366   return jresult;
21367 }
21368
21369
21370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21371   unsigned int jresult ;
21372   unsigned int result;
21373
21374   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21375   jresult = result;
21376   return jresult;
21377 }
21378
21379
21380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21381   unsigned int jresult ;
21382   unsigned int result;
21383
21384   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21385   jresult = result;
21386   return jresult;
21387 }
21388
21389
21390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21391   unsigned int jresult ;
21392   unsigned int result;
21393
21394   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21395   jresult = result;
21396   return jresult;
21397 }
21398
21399
21400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21401   void * jresult ;
21402   Dali::TextureType::Type arg1 ;
21403   Dali::Pixel::Format arg2 ;
21404   unsigned int arg3 ;
21405   unsigned int arg4 ;
21406   Dali::Texture result;
21407
21408   arg1 = (Dali::TextureType::Type)jarg1;
21409   arg2 = (Dali::Pixel::Format)jarg2;
21410   arg3 = (unsigned int)jarg3;
21411   arg4 = (unsigned int)jarg4;
21412   {
21413     try {
21414       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
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 (...) {
21424       {
21425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21426       };
21427     }
21428   }
21429   jresult = new Dali::Texture((const Dali::Texture &)result);
21430   return jresult;
21431 }
21432
21433
21434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21435   void * jresult ;
21436   NativeImageInterface *arg1 = 0 ;
21437   Dali::Texture result;
21438
21439   arg1 = (NativeImageInterface *)jarg1;
21440   if (!arg1) {
21441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21442     return 0;
21443   }
21444   {
21445     try {
21446       result = Dali::Texture::New(*arg1);
21447     } catch (std::out_of_range& e) {
21448       {
21449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21450       };
21451     } catch (std::exception& e) {
21452       {
21453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21454       };
21455     } catch (...) {
21456       {
21457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21458       };
21459     }
21460   }
21461   jresult = new Dali::Texture((const Dali::Texture &)result);
21462   return jresult;
21463 }
21464
21465
21466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21467   void * jresult ;
21468   Dali::Texture *result = 0 ;
21469
21470   {
21471     try {
21472       result = (Dali::Texture *)new Dali::Texture();
21473     } catch (std::out_of_range& e) {
21474       {
21475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21476       };
21477     } catch (std::exception& e) {
21478       {
21479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21480       };
21481     } catch (...) {
21482       {
21483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21484       };
21485     }
21486   }
21487   jresult = (void *)result;
21488   return jresult;
21489 }
21490
21491
21492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21493   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21494
21495   arg1 = (Dali::Texture *)jarg1;
21496   {
21497     try {
21498       delete arg1;
21499     } catch (std::out_of_range& e) {
21500       {
21501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21502       };
21503     } catch (std::exception& e) {
21504       {
21505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21506       };
21507     } catch (...) {
21508       {
21509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21510       };
21511     }
21512   }
21513 }
21514
21515
21516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21517   void * jresult ;
21518   Dali::Texture *arg1 = 0 ;
21519   Dali::Texture *result = 0 ;
21520
21521   arg1 = (Dali::Texture *)jarg1;
21522   if (!arg1) {
21523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21524     return 0;
21525   }
21526   {
21527     try {
21528       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21529     } catch (std::out_of_range& e) {
21530       {
21531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21532       };
21533     } catch (std::exception& e) {
21534       {
21535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21536       };
21537     } catch (...) {
21538       {
21539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21540       };
21541     }
21542   }
21543   jresult = (void *)result;
21544   return jresult;
21545 }
21546
21547
21548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21549   void * jresult ;
21550   Dali::BaseHandle arg1 ;
21551   Dali::BaseHandle *argp1 ;
21552   Dali::Texture result;
21553
21554   argp1 = (Dali::BaseHandle *)jarg1;
21555   if (!argp1) {
21556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21557     return 0;
21558   }
21559   arg1 = *argp1;
21560   {
21561     try {
21562       result = Dali::Texture::DownCast(arg1);
21563     } catch (std::out_of_range& e) {
21564       {
21565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21566       };
21567     } catch (std::exception& e) {
21568       {
21569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21570       };
21571     } catch (...) {
21572       {
21573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21574       };
21575     }
21576   }
21577   jresult = new Dali::Texture((const Dali::Texture &)result);
21578   return jresult;
21579 }
21580
21581
21582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21583   void * jresult ;
21584   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21585   Dali::Texture *arg2 = 0 ;
21586   Dali::Texture *result = 0 ;
21587
21588   arg1 = (Dali::Texture *)jarg1;
21589   arg2 = (Dali::Texture *)jarg2;
21590   if (!arg2) {
21591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21592     return 0;
21593   }
21594   {
21595     try {
21596       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21597     } catch (std::out_of_range& e) {
21598       {
21599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21600       };
21601     } catch (std::exception& e) {
21602       {
21603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21604       };
21605     } catch (...) {
21606       {
21607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21608       };
21609     }
21610   }
21611   jresult = (void *)result;
21612   return jresult;
21613 }
21614
21615
21616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21617   unsigned int jresult ;
21618   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21619   Dali::PixelData arg2 ;
21620   Dali::PixelData *argp2 ;
21621   bool result;
21622
21623   arg1 = (Dali::Texture *)jarg1;
21624   argp2 = (Dali::PixelData *)jarg2;
21625   if (!argp2) {
21626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21627     return 0;
21628   }
21629   arg2 = *argp2;
21630   {
21631     try {
21632       result = (bool)(arg1)->Upload(arg2);
21633     } catch (std::out_of_range& e) {
21634       {
21635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21636       };
21637     } catch (std::exception& e) {
21638       {
21639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21640       };
21641     } catch (...) {
21642       {
21643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21644       };
21645     }
21646   }
21647   jresult = result;
21648   return jresult;
21649 }
21650
21651
21652 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) {
21653   unsigned int jresult ;
21654   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21655   Dali::PixelData arg2 ;
21656   unsigned int arg3 ;
21657   unsigned int arg4 ;
21658   unsigned int arg5 ;
21659   unsigned int arg6 ;
21660   unsigned int arg7 ;
21661   unsigned int arg8 ;
21662   Dali::PixelData *argp2 ;
21663   bool result;
21664
21665   arg1 = (Dali::Texture *)jarg1;
21666   argp2 = (Dali::PixelData *)jarg2;
21667   if (!argp2) {
21668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21669     return 0;
21670   }
21671   arg2 = *argp2;
21672   arg3 = (unsigned int)jarg3;
21673   arg4 = (unsigned int)jarg4;
21674   arg5 = (unsigned int)jarg5;
21675   arg6 = (unsigned int)jarg6;
21676   arg7 = (unsigned int)jarg7;
21677   arg8 = (unsigned int)jarg8;
21678   {
21679     try {
21680       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21681     } catch (std::out_of_range& e) {
21682       {
21683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21684       };
21685     } catch (std::exception& e) {
21686       {
21687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21688       };
21689     } catch (...) {
21690       {
21691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21692       };
21693     }
21694   }
21695   jresult = result;
21696   return jresult;
21697 }
21698
21699
21700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21701   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21702
21703   arg1 = (Dali::Texture *)jarg1;
21704   {
21705     try {
21706       (arg1)->GenerateMipmaps();
21707     } catch (std::out_of_range& e) {
21708       {
21709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21710       };
21711     } catch (std::exception& e) {
21712       {
21713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21714       };
21715     } catch (...) {
21716       {
21717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21718       };
21719     }
21720   }
21721 }
21722
21723
21724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21725   unsigned int jresult ;
21726   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21727   unsigned int result;
21728
21729   arg1 = (Dali::Texture *)jarg1;
21730   {
21731     try {
21732       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21733     } catch (std::out_of_range& e) {
21734       {
21735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21736       };
21737     } catch (std::exception& e) {
21738       {
21739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21740       };
21741     } catch (...) {
21742       {
21743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21744       };
21745     }
21746   }
21747   jresult = result;
21748   return jresult;
21749 }
21750
21751
21752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21753   unsigned int jresult ;
21754   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21755   unsigned int result;
21756
21757   arg1 = (Dali::Texture *)jarg1;
21758   {
21759     try {
21760       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21761     } catch (std::out_of_range& e) {
21762       {
21763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21764       };
21765     } catch (std::exception& e) {
21766       {
21767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21768       };
21769     } catch (...) {
21770       {
21771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21772       };
21773     }
21774   }
21775   jresult = result;
21776   return jresult;
21777 }
21778
21779
21780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21781   void * jresult ;
21782   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21783   Dali::Texture *result = 0 ;
21784
21785   arg1 = (Dali::Internal::Texture *)jarg1;
21786   {
21787     try {
21788       result = (Dali::Texture *)new Dali::Texture(arg1);
21789     } catch (std::out_of_range& e) {
21790       {
21791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21792       };
21793     } catch (std::exception& e) {
21794       {
21795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21796       };
21797     } catch (...) {
21798       {
21799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21800       };
21801     }
21802   }
21803   jresult = (void *)result;
21804   return jresult;
21805 }
21806
21807
21808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21809   void * jresult ;
21810   Dali::Sampler result;
21811
21812   {
21813     try {
21814       result = Dali::Sampler::New();
21815     } catch (std::out_of_range& e) {
21816       {
21817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21818       };
21819     } catch (std::exception& e) {
21820       {
21821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21822       };
21823     } catch (...) {
21824       {
21825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21826       };
21827     }
21828   }
21829   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21830   return jresult;
21831 }
21832
21833
21834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21835   void * jresult ;
21836   Dali::Sampler *result = 0 ;
21837
21838   {
21839     try {
21840       result = (Dali::Sampler *)new Dali::Sampler();
21841     } catch (std::out_of_range& e) {
21842       {
21843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21844       };
21845     } catch (std::exception& e) {
21846       {
21847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21848       };
21849     } catch (...) {
21850       {
21851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21852       };
21853     }
21854   }
21855   jresult = (void *)result;
21856   return jresult;
21857 }
21858
21859
21860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21861   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21862
21863   arg1 = (Dali::Sampler *)jarg1;
21864   {
21865     try {
21866       delete arg1;
21867     } catch (std::out_of_range& e) {
21868       {
21869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21870       };
21871     } catch (std::exception& e) {
21872       {
21873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21874       };
21875     } catch (...) {
21876       {
21877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21878       };
21879     }
21880   }
21881 }
21882
21883
21884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21885   void * jresult ;
21886   Dali::Sampler *arg1 = 0 ;
21887   Dali::Sampler *result = 0 ;
21888
21889   arg1 = (Dali::Sampler *)jarg1;
21890   if (!arg1) {
21891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21892     return 0;
21893   }
21894   {
21895     try {
21896       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21897     } catch (std::out_of_range& e) {
21898       {
21899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21900       };
21901     } catch (std::exception& e) {
21902       {
21903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21904       };
21905     } catch (...) {
21906       {
21907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21908       };
21909     }
21910   }
21911   jresult = (void *)result;
21912   return jresult;
21913 }
21914
21915
21916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21917   void * jresult ;
21918   Dali::BaseHandle arg1 ;
21919   Dali::BaseHandle *argp1 ;
21920   Dali::Sampler result;
21921
21922   argp1 = (Dali::BaseHandle *)jarg1;
21923   if (!argp1) {
21924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21925     return 0;
21926   }
21927   arg1 = *argp1;
21928   {
21929     try {
21930       result = Dali::Sampler::DownCast(arg1);
21931     } catch (std::out_of_range& e) {
21932       {
21933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21934       };
21935     } catch (std::exception& e) {
21936       {
21937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21938       };
21939     } catch (...) {
21940       {
21941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21942       };
21943     }
21944   }
21945   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21946   return jresult;
21947 }
21948
21949
21950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21951   void * jresult ;
21952   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21953   Dali::Sampler *arg2 = 0 ;
21954   Dali::Sampler *result = 0 ;
21955
21956   arg1 = (Dali::Sampler *)jarg1;
21957   arg2 = (Dali::Sampler *)jarg2;
21958   if (!arg2) {
21959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21960     return 0;
21961   }
21962   {
21963     try {
21964       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21965     } catch (std::out_of_range& e) {
21966       {
21967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21968       };
21969     } catch (std::exception& e) {
21970       {
21971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21972       };
21973     } catch (...) {
21974       {
21975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21976       };
21977     }
21978   }
21979   jresult = (void *)result;
21980   return jresult;
21981 }
21982
21983
21984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
21985   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21986   Dali::FilterMode::Type arg2 ;
21987   Dali::FilterMode::Type arg3 ;
21988
21989   arg1 = (Dali::Sampler *)jarg1;
21990   arg2 = (Dali::FilterMode::Type)jarg2;
21991   arg3 = (Dali::FilterMode::Type)jarg3;
21992   {
21993     try {
21994       (arg1)->SetFilterMode(arg2,arg3);
21995     } catch (std::out_of_range& e) {
21996       {
21997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21998       };
21999     } catch (std::exception& e) {
22000       {
22001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22002       };
22003     } catch (...) {
22004       {
22005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22006       };
22007     }
22008   }
22009 }
22010
22011
22012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22013   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22014   Dali::WrapMode::Type arg2 ;
22015   Dali::WrapMode::Type arg3 ;
22016
22017   arg1 = (Dali::Sampler *)jarg1;
22018   arg2 = (Dali::WrapMode::Type)jarg2;
22019   arg3 = (Dali::WrapMode::Type)jarg3;
22020   {
22021     try {
22022       (arg1)->SetWrapMode(arg2,arg3);
22023     } catch (std::out_of_range& e) {
22024       {
22025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22026       };
22027     } catch (std::exception& e) {
22028       {
22029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22030       };
22031     } catch (...) {
22032       {
22033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22034       };
22035     }
22036   }
22037 }
22038
22039
22040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22041   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22042   Dali::WrapMode::Type arg2 ;
22043   Dali::WrapMode::Type arg3 ;
22044   Dali::WrapMode::Type arg4 ;
22045
22046   arg1 = (Dali::Sampler *)jarg1;
22047   arg2 = (Dali::WrapMode::Type)jarg2;
22048   arg3 = (Dali::WrapMode::Type)jarg3;
22049   arg4 = (Dali::WrapMode::Type)jarg4;
22050   {
22051     try {
22052       (arg1)->SetWrapMode(arg2,arg3,arg4);
22053     } catch (std::out_of_range& e) {
22054       {
22055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22056       };
22057     } catch (std::exception& e) {
22058       {
22059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22060       };
22061     } catch (...) {
22062       {
22063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22064       };
22065     }
22066   }
22067 }
22068
22069
22070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22071   void * jresult ;
22072   Dali::TextureSet result;
22073
22074   {
22075     try {
22076       result = Dali::TextureSet::New();
22077     } catch (std::out_of_range& e) {
22078       {
22079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22080       };
22081     } catch (std::exception& e) {
22082       {
22083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22084       };
22085     } catch (...) {
22086       {
22087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22088       };
22089     }
22090   }
22091   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22092   return jresult;
22093 }
22094
22095
22096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22097   void * jresult ;
22098   Dali::TextureSet *result = 0 ;
22099
22100   {
22101     try {
22102       result = (Dali::TextureSet *)new Dali::TextureSet();
22103     } catch (std::out_of_range& e) {
22104       {
22105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22106       };
22107     } catch (std::exception& e) {
22108       {
22109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22110       };
22111     } catch (...) {
22112       {
22113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22114       };
22115     }
22116   }
22117   jresult = (void *)result;
22118   return jresult;
22119 }
22120
22121
22122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22123   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22124
22125   arg1 = (Dali::TextureSet *)jarg1;
22126   {
22127     try {
22128       delete arg1;
22129     } catch (std::out_of_range& e) {
22130       {
22131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22132       };
22133     } catch (std::exception& e) {
22134       {
22135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22136       };
22137     } catch (...) {
22138       {
22139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22140       };
22141     }
22142   }
22143 }
22144
22145
22146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22147   void * jresult ;
22148   Dali::TextureSet *arg1 = 0 ;
22149   Dali::TextureSet *result = 0 ;
22150
22151   arg1 = (Dali::TextureSet *)jarg1;
22152   if (!arg1) {
22153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22154     return 0;
22155   }
22156   {
22157     try {
22158       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22159     } catch (std::out_of_range& e) {
22160       {
22161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22162       };
22163     } catch (std::exception& e) {
22164       {
22165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22166       };
22167     } catch (...) {
22168       {
22169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22170       };
22171     }
22172   }
22173   jresult = (void *)result;
22174   return jresult;
22175 }
22176
22177
22178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22179   void * jresult ;
22180   Dali::BaseHandle arg1 ;
22181   Dali::BaseHandle *argp1 ;
22182   Dali::TextureSet result;
22183
22184   argp1 = (Dali::BaseHandle *)jarg1;
22185   if (!argp1) {
22186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22187     return 0;
22188   }
22189   arg1 = *argp1;
22190   {
22191     try {
22192       result = Dali::TextureSet::DownCast(arg1);
22193     } catch (std::out_of_range& e) {
22194       {
22195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22196       };
22197     } catch (std::exception& e) {
22198       {
22199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22200       };
22201     } catch (...) {
22202       {
22203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22204       };
22205     }
22206   }
22207   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22208   return jresult;
22209 }
22210
22211
22212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22213   void * jresult ;
22214   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22215   Dali::TextureSet *arg2 = 0 ;
22216   Dali::TextureSet *result = 0 ;
22217
22218   arg1 = (Dali::TextureSet *)jarg1;
22219   arg2 = (Dali::TextureSet *)jarg2;
22220   if (!arg2) {
22221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22222     return 0;
22223   }
22224   {
22225     try {
22226       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22227     } catch (std::out_of_range& e) {
22228       {
22229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22230       };
22231     } catch (std::exception& e) {
22232       {
22233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22234       };
22235     } catch (...) {
22236       {
22237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22238       };
22239     }
22240   }
22241   jresult = (void *)result;
22242   return jresult;
22243 }
22244
22245
22246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22247   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22248   size_t arg2 ;
22249   Dali::Texture arg3 ;
22250   Dali::Texture *argp3 ;
22251
22252   arg1 = (Dali::TextureSet *)jarg1;
22253   arg2 = (size_t)jarg2;
22254   argp3 = (Dali::Texture *)jarg3;
22255   if (!argp3) {
22256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22257     return ;
22258   }
22259   arg3 = *argp3;
22260   {
22261     try {
22262       (arg1)->SetTexture(arg2,arg3);
22263     } catch (std::out_of_range& e) {
22264       {
22265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22266       };
22267     } catch (std::exception& e) {
22268       {
22269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22270       };
22271     } catch (...) {
22272       {
22273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22274       };
22275     }
22276   }
22277 }
22278
22279
22280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22281   void * jresult ;
22282   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22283   size_t arg2 ;
22284   Dali::Texture result;
22285
22286   arg1 = (Dali::TextureSet *)jarg1;
22287   arg2 = (size_t)jarg2;
22288   {
22289     try {
22290       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22291     } catch (std::out_of_range& e) {
22292       {
22293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22294       };
22295     } catch (std::exception& e) {
22296       {
22297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22298       };
22299     } catch (...) {
22300       {
22301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22302       };
22303     }
22304   }
22305   jresult = new Dali::Texture((const Dali::Texture &)result);
22306   return jresult;
22307 }
22308
22309
22310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22311   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22312   size_t arg2 ;
22313   Dali::Sampler arg3 ;
22314   Dali::Sampler *argp3 ;
22315
22316   arg1 = (Dali::TextureSet *)jarg1;
22317   arg2 = (size_t)jarg2;
22318   argp3 = (Dali::Sampler *)jarg3;
22319   if (!argp3) {
22320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22321     return ;
22322   }
22323   arg3 = *argp3;
22324   {
22325     try {
22326       (arg1)->SetSampler(arg2,arg3);
22327     } catch (std::out_of_range& e) {
22328       {
22329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22330       };
22331     } catch (std::exception& e) {
22332       {
22333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22334       };
22335     } catch (...) {
22336       {
22337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22338       };
22339     }
22340   }
22341 }
22342
22343
22344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22345   void * jresult ;
22346   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22347   size_t arg2 ;
22348   Dali::Sampler result;
22349
22350   arg1 = (Dali::TextureSet *)jarg1;
22351   arg2 = (size_t)jarg2;
22352   {
22353     try {
22354       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22355     } catch (std::out_of_range& e) {
22356       {
22357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22358       };
22359     } catch (std::exception& e) {
22360       {
22361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22362       };
22363     } catch (...) {
22364       {
22365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22366       };
22367     }
22368   }
22369   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22370   return jresult;
22371 }
22372
22373
22374 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22375   unsigned long jresult ;
22376   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22377   size_t result;
22378
22379   arg1 = (Dali::TextureSet *)jarg1;
22380   {
22381     try {
22382       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22383     } catch (std::out_of_range& e) {
22384       {
22385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22386       };
22387     } catch (std::exception& e) {
22388       {
22389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22390       };
22391     } catch (...) {
22392       {
22393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22394       };
22395     }
22396   }
22397   jresult = (unsigned long)result;
22398   return jresult;
22399 }
22400
22401
22402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22403   void * jresult ;
22404   Dali::Property::Map *arg1 = 0 ;
22405   Dali::PropertyBuffer result;
22406
22407   arg1 = (Dali::Property::Map *)jarg1;
22408   if (!arg1) {
22409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22410     return 0;
22411   }
22412   {
22413     try {
22414       result = Dali::PropertyBuffer::New(*arg1);
22415     } catch (std::out_of_range& e) {
22416       {
22417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22418       };
22419     } catch (std::exception& e) {
22420       {
22421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22422       };
22423     } catch (...) {
22424       {
22425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22426       };
22427     }
22428   }
22429   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22430   return jresult;
22431 }
22432
22433
22434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22435   void * jresult ;
22436   Dali::PropertyBuffer *result = 0 ;
22437
22438   {
22439     try {
22440       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22441     } catch (std::out_of_range& e) {
22442       {
22443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22444       };
22445     } catch (std::exception& e) {
22446       {
22447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22448       };
22449     } catch (...) {
22450       {
22451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22452       };
22453     }
22454   }
22455   jresult = (void *)result;
22456   return jresult;
22457 }
22458
22459
22460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22461   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22462
22463   arg1 = (Dali::PropertyBuffer *)jarg1;
22464   {
22465     try {
22466       delete arg1;
22467     } catch (std::out_of_range& e) {
22468       {
22469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22470       };
22471     } catch (std::exception& e) {
22472       {
22473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22474       };
22475     } catch (...) {
22476       {
22477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22478       };
22479     }
22480   }
22481 }
22482
22483
22484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22485   void * jresult ;
22486   Dali::PropertyBuffer *arg1 = 0 ;
22487   Dali::PropertyBuffer *result = 0 ;
22488
22489   arg1 = (Dali::PropertyBuffer *)jarg1;
22490   if (!arg1) {
22491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22492     return 0;
22493   }
22494   {
22495     try {
22496       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22497     } catch (std::out_of_range& e) {
22498       {
22499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22500       };
22501     } catch (std::exception& e) {
22502       {
22503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22504       };
22505     } catch (...) {
22506       {
22507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22508       };
22509     }
22510   }
22511   jresult = (void *)result;
22512   return jresult;
22513 }
22514
22515
22516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22517   void * jresult ;
22518   Dali::BaseHandle arg1 ;
22519   Dali::BaseHandle *argp1 ;
22520   Dali::PropertyBuffer result;
22521
22522   argp1 = (Dali::BaseHandle *)jarg1;
22523   if (!argp1) {
22524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22525     return 0;
22526   }
22527   arg1 = *argp1;
22528   {
22529     try {
22530       result = Dali::PropertyBuffer::DownCast(arg1);
22531     } catch (std::out_of_range& e) {
22532       {
22533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22534       };
22535     } catch (std::exception& e) {
22536       {
22537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22538       };
22539     } catch (...) {
22540       {
22541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22542       };
22543     }
22544   }
22545   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22546   return jresult;
22547 }
22548
22549
22550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22551   void * jresult ;
22552   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22553   Dali::PropertyBuffer *arg2 = 0 ;
22554   Dali::PropertyBuffer *result = 0 ;
22555
22556   arg1 = (Dali::PropertyBuffer *)jarg1;
22557   arg2 = (Dali::PropertyBuffer *)jarg2;
22558   if (!arg2) {
22559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22560     return 0;
22561   }
22562   {
22563     try {
22564       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22565     } catch (std::out_of_range& e) {
22566       {
22567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22568       };
22569     } catch (std::exception& e) {
22570       {
22571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22572       };
22573     } catch (...) {
22574       {
22575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22576       };
22577     }
22578   }
22579   jresult = (void *)result;
22580   return jresult;
22581 }
22582
22583
22584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22585   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22586   void *arg2 = (void *) 0 ;
22587   std::size_t arg3 ;
22588
22589   arg1 = (Dali::PropertyBuffer *)jarg1;
22590   arg2 = jarg2;
22591   arg3 = (std::size_t)jarg3;
22592   {
22593     try {
22594       (arg1)->SetData((void const *)arg2,arg3);
22595     } catch (std::out_of_range& e) {
22596       {
22597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22598       };
22599     } catch (std::exception& e) {
22600       {
22601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22602       };
22603     } catch (...) {
22604       {
22605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22606       };
22607     }
22608   }
22609 }
22610
22611
22612 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22613   unsigned long jresult ;
22614   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22615   std::size_t result;
22616
22617   arg1 = (Dali::PropertyBuffer *)jarg1;
22618   {
22619     try {
22620       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22621     } catch (std::out_of_range& e) {
22622       {
22623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22624       };
22625     } catch (std::exception& e) {
22626       {
22627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22628       };
22629     } catch (...) {
22630       {
22631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22632       };
22633     }
22634   }
22635   jresult = (unsigned long)result;
22636   return jresult;
22637 }
22638
22639
22640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22641   void * jresult ;
22642   Dali::Geometry result;
22643
22644   {
22645     try {
22646       result = Dali::Geometry::New();
22647     } catch (std::out_of_range& e) {
22648       {
22649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22650       };
22651     } catch (std::exception& e) {
22652       {
22653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22654       };
22655     } catch (...) {
22656       {
22657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22658       };
22659     }
22660   }
22661   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22662   return jresult;
22663 }
22664
22665
22666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22667   void * jresult ;
22668   Dali::Geometry *result = 0 ;
22669
22670   {
22671     try {
22672       result = (Dali::Geometry *)new Dali::Geometry();
22673     } catch (std::out_of_range& e) {
22674       {
22675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22676       };
22677     } catch (std::exception& e) {
22678       {
22679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22680       };
22681     } catch (...) {
22682       {
22683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22684       };
22685     }
22686   }
22687   jresult = (void *)result;
22688   return jresult;
22689 }
22690
22691
22692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22693   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22694
22695   arg1 = (Dali::Geometry *)jarg1;
22696   {
22697     try {
22698       delete arg1;
22699     } catch (std::out_of_range& e) {
22700       {
22701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22702       };
22703     } catch (std::exception& e) {
22704       {
22705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22706       };
22707     } catch (...) {
22708       {
22709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22710       };
22711     }
22712   }
22713 }
22714
22715
22716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22717   void * jresult ;
22718   Dali::Geometry *arg1 = 0 ;
22719   Dali::Geometry *result = 0 ;
22720
22721   arg1 = (Dali::Geometry *)jarg1;
22722   if (!arg1) {
22723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22724     return 0;
22725   }
22726   {
22727     try {
22728       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22729     } catch (std::out_of_range& e) {
22730       {
22731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22732       };
22733     } catch (std::exception& e) {
22734       {
22735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22736       };
22737     } catch (...) {
22738       {
22739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22740       };
22741     }
22742   }
22743   jresult = (void *)result;
22744   return jresult;
22745 }
22746
22747
22748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22749   void * jresult ;
22750   Dali::BaseHandle arg1 ;
22751   Dali::BaseHandle *argp1 ;
22752   Dali::Geometry result;
22753
22754   argp1 = (Dali::BaseHandle *)jarg1;
22755   if (!argp1) {
22756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22757     return 0;
22758   }
22759   arg1 = *argp1;
22760   {
22761     try {
22762       result = Dali::Geometry::DownCast(arg1);
22763     } catch (std::out_of_range& e) {
22764       {
22765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22766       };
22767     } catch (std::exception& e) {
22768       {
22769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22770       };
22771     } catch (...) {
22772       {
22773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22774       };
22775     }
22776   }
22777   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22778   return jresult;
22779 }
22780
22781
22782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22783   void * jresult ;
22784   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22785   Dali::Geometry *arg2 = 0 ;
22786   Dali::Geometry *result = 0 ;
22787
22788   arg1 = (Dali::Geometry *)jarg1;
22789   arg2 = (Dali::Geometry *)jarg2;
22790   if (!arg2) {
22791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22792     return 0;
22793   }
22794   {
22795     try {
22796       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22797     } catch (std::out_of_range& e) {
22798       {
22799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22800       };
22801     } catch (std::exception& e) {
22802       {
22803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22804       };
22805     } catch (...) {
22806       {
22807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22808       };
22809     }
22810   }
22811   jresult = (void *)result;
22812   return jresult;
22813 }
22814
22815
22816 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22817   unsigned long jresult ;
22818   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22819   Dali::PropertyBuffer *arg2 = 0 ;
22820   std::size_t result;
22821
22822   arg1 = (Dali::Geometry *)jarg1;
22823   arg2 = (Dali::PropertyBuffer *)jarg2;
22824   if (!arg2) {
22825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22826     return 0;
22827   }
22828   {
22829     try {
22830       result = (arg1)->AddVertexBuffer(*arg2);
22831     } catch (std::out_of_range& e) {
22832       {
22833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22834       };
22835     } catch (std::exception& e) {
22836       {
22837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22838       };
22839     } catch (...) {
22840       {
22841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22842       };
22843     }
22844   }
22845   jresult = (unsigned long)result;
22846   return jresult;
22847 }
22848
22849
22850 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22851   unsigned long jresult ;
22852   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22853   std::size_t result;
22854
22855   arg1 = (Dali::Geometry *)jarg1;
22856   {
22857     try {
22858       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22859     } catch (std::out_of_range& e) {
22860       {
22861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22862       };
22863     } catch (std::exception& e) {
22864       {
22865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22866       };
22867     } catch (...) {
22868       {
22869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22870       };
22871     }
22872   }
22873   jresult = (unsigned long)result;
22874   return jresult;
22875 }
22876
22877
22878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22879   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22880   std::size_t arg2 ;
22881
22882   arg1 = (Dali::Geometry *)jarg1;
22883   arg2 = (std::size_t)jarg2;
22884   {
22885     try {
22886       (arg1)->RemoveVertexBuffer(arg2);
22887     } catch (std::out_of_range& e) {
22888       {
22889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22890       };
22891     } catch (std::exception& e) {
22892       {
22893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22894       };
22895     } catch (...) {
22896       {
22897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22898       };
22899     }
22900   }
22901 }
22902
22903
22904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22905   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22906   unsigned short *arg2 = (unsigned short *) 0 ;
22907   size_t arg3 ;
22908
22909   arg1 = (Dali::Geometry *)jarg1;
22910   arg2 = jarg2;
22911   arg3 = (size_t)jarg3;
22912   {
22913     try {
22914       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22915     } catch (std::out_of_range& e) {
22916       {
22917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22918       };
22919     } catch (std::exception& e) {
22920       {
22921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22922       };
22923     } catch (...) {
22924       {
22925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22926       };
22927     }
22928   }
22929
22930
22931 }
22932
22933
22934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22935   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22936   Dali::Geometry::Type arg2 ;
22937
22938   arg1 = (Dali::Geometry *)jarg1;
22939   arg2 = (Dali::Geometry::Type)jarg2;
22940   {
22941     try {
22942       (arg1)->SetType(arg2);
22943     } catch (std::out_of_range& e) {
22944       {
22945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22946       };
22947     } catch (std::exception& e) {
22948       {
22949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22950       };
22951     } catch (...) {
22952       {
22953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22954       };
22955     }
22956   }
22957 }
22958
22959
22960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22961   int jresult ;
22962   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22963   Dali::Geometry::Type result;
22964
22965   arg1 = (Dali::Geometry *)jarg1;
22966   {
22967     try {
22968       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22969     } catch (std::out_of_range& e) {
22970       {
22971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22972       };
22973     } catch (std::exception& e) {
22974       {
22975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22976       };
22977     } catch (...) {
22978       {
22979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22980       };
22981     }
22982   }
22983   jresult = (int)result;
22984   return jresult;
22985 }
22986
22987
22988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
22989   void * jresult ;
22990   Dali::Shader::Hint *result = 0 ;
22991
22992   {
22993     try {
22994       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
22995     } catch (std::out_of_range& e) {
22996       {
22997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22998       };
22999     } catch (std::exception& e) {
23000       {
23001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23002       };
23003     } catch (...) {
23004       {
23005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23006       };
23007     }
23008   }
23009   jresult = (void *)result;
23010   return jresult;
23011 }
23012
23013
23014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23015   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23016
23017   arg1 = (Dali::Shader::Hint *)jarg1;
23018   {
23019     try {
23020       delete arg1;
23021     } catch (std::out_of_range& e) {
23022       {
23023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23024       };
23025     } catch (std::exception& e) {
23026       {
23027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23028       };
23029     } catch (...) {
23030       {
23031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23032       };
23033     }
23034   }
23035 }
23036
23037
23038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23039   int jresult ;
23040   int result;
23041
23042   result = (int)Dali::Shader::Property::PROGRAM;
23043   jresult = (int)result;
23044   return jresult;
23045 }
23046
23047
23048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23049   void * jresult ;
23050   Dali::Shader::Property *result = 0 ;
23051
23052   {
23053     try {
23054       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23055     } catch (std::out_of_range& e) {
23056       {
23057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23058       };
23059     } catch (std::exception& e) {
23060       {
23061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23062       };
23063     } catch (...) {
23064       {
23065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23066       };
23067     }
23068   }
23069   jresult = (void *)result;
23070   return jresult;
23071 }
23072
23073
23074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23075   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23076
23077   arg1 = (Dali::Shader::Property *)jarg1;
23078   {
23079     try {
23080       delete arg1;
23081     } catch (std::out_of_range& e) {
23082       {
23083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23084       };
23085     } catch (std::exception& e) {
23086       {
23087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23088       };
23089     } catch (...) {
23090       {
23091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23092       };
23093     }
23094   }
23095 }
23096
23097
23098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23099   void * jresult ;
23100   std::string *arg1 = 0 ;
23101   std::string *arg2 = 0 ;
23102   Dali::Shader::Hint::Value arg3 ;
23103   Dali::Shader result;
23104
23105   if (!jarg1) {
23106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23107     return 0;
23108   }
23109   std::string arg1_str(jarg1);
23110   arg1 = &arg1_str;
23111   if (!jarg2) {
23112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23113     return 0;
23114   }
23115   std::string arg2_str(jarg2);
23116   arg2 = &arg2_str;
23117   arg3 = (Dali::Shader::Hint::Value)jarg3;
23118   {
23119     try {
23120       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23121     } catch (std::out_of_range& e) {
23122       {
23123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23124       };
23125     } catch (std::exception& e) {
23126       {
23127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23128       };
23129     } catch (...) {
23130       {
23131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23132       };
23133     }
23134   }
23135   jresult = new Dali::Shader((const Dali::Shader &)result);
23136
23137   //argout typemap for const std::string&
23138
23139
23140   //argout typemap for const std::string&
23141
23142   return jresult;
23143 }
23144
23145
23146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23147   void * jresult ;
23148   std::string *arg1 = 0 ;
23149   std::string *arg2 = 0 ;
23150   Dali::Shader result;
23151
23152   if (!jarg1) {
23153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23154     return 0;
23155   }
23156   std::string arg1_str(jarg1);
23157   arg1 = &arg1_str;
23158   if (!jarg2) {
23159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23160     return 0;
23161   }
23162   std::string arg2_str(jarg2);
23163   arg2 = &arg2_str;
23164   {
23165     try {
23166       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23167     } catch (std::out_of_range& e) {
23168       {
23169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23170       };
23171     } catch (std::exception& e) {
23172       {
23173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23174       };
23175     } catch (...) {
23176       {
23177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23178       };
23179     }
23180   }
23181   jresult = new Dali::Shader((const Dali::Shader &)result);
23182
23183   //argout typemap for const std::string&
23184
23185
23186   //argout typemap for const std::string&
23187
23188   return jresult;
23189 }
23190
23191
23192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23193   void * jresult ;
23194   Dali::Shader *result = 0 ;
23195
23196   {
23197     try {
23198       result = (Dali::Shader *)new Dali::Shader();
23199     } catch (std::out_of_range& e) {
23200       {
23201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23202       };
23203     } catch (std::exception& e) {
23204       {
23205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23206       };
23207     } catch (...) {
23208       {
23209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23210       };
23211     }
23212   }
23213   jresult = (void *)result;
23214   return jresult;
23215 }
23216
23217
23218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23219   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23220
23221   arg1 = (Dali::Shader *)jarg1;
23222   {
23223     try {
23224       delete arg1;
23225     } catch (std::out_of_range& e) {
23226       {
23227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23228       };
23229     } catch (std::exception& e) {
23230       {
23231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23232       };
23233     } catch (...) {
23234       {
23235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23236       };
23237     }
23238   }
23239 }
23240
23241
23242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23243   void * jresult ;
23244   Dali::Shader *arg1 = 0 ;
23245   Dali::Shader *result = 0 ;
23246
23247   arg1 = (Dali::Shader *)jarg1;
23248   if (!arg1) {
23249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23250     return 0;
23251   }
23252   {
23253     try {
23254       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23255     } catch (std::out_of_range& e) {
23256       {
23257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23258       };
23259     } catch (std::exception& e) {
23260       {
23261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23262       };
23263     } catch (...) {
23264       {
23265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23266       };
23267     }
23268   }
23269   jresult = (void *)result;
23270   return jresult;
23271 }
23272
23273
23274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23275   void * jresult ;
23276   Dali::BaseHandle arg1 ;
23277   Dali::BaseHandle *argp1 ;
23278   Dali::Shader result;
23279
23280   argp1 = (Dali::BaseHandle *)jarg1;
23281   if (!argp1) {
23282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23283     return 0;
23284   }
23285   arg1 = *argp1;
23286   {
23287     try {
23288       result = Dali::Shader::DownCast(arg1);
23289     } catch (std::out_of_range& e) {
23290       {
23291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23292       };
23293     } catch (std::exception& e) {
23294       {
23295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23296       };
23297     } catch (...) {
23298       {
23299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23300       };
23301     }
23302   }
23303   jresult = new Dali::Shader((const Dali::Shader &)result);
23304   return jresult;
23305 }
23306
23307
23308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23309   void * jresult ;
23310   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23311   Dali::Shader *arg2 = 0 ;
23312   Dali::Shader *result = 0 ;
23313
23314   arg1 = (Dali::Shader *)jarg1;
23315   arg2 = (Dali::Shader *)jarg2;
23316   if (!arg2) {
23317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23318     return 0;
23319   }
23320   {
23321     try {
23322       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23323     } catch (std::out_of_range& e) {
23324       {
23325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23326       };
23327     } catch (std::exception& e) {
23328       {
23329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23330       };
23331     } catch (...) {
23332       {
23333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23334       };
23335     }
23336   }
23337   jresult = (void *)result;
23338   return jresult;
23339 }
23340
23341
23342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23343   int jresult ;
23344   int result;
23345
23346   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23347   jresult = (int)result;
23348   return jresult;
23349 }
23350
23351
23352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23353   int jresult ;
23354   int result;
23355
23356   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23357   jresult = (int)result;
23358   return jresult;
23359 }
23360
23361
23362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23363   int jresult ;
23364   int result;
23365
23366   result = (int)Dali::Renderer::Property::BLEND_MODE;
23367   jresult = (int)result;
23368   return jresult;
23369 }
23370
23371
23372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23373   int jresult ;
23374   int result;
23375
23376   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23377   jresult = (int)result;
23378   return jresult;
23379 }
23380
23381
23382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23383   int jresult ;
23384   int result;
23385
23386   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23387   jresult = (int)result;
23388   return jresult;
23389 }
23390
23391
23392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23393   int jresult ;
23394   int result;
23395
23396   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23397   jresult = (int)result;
23398   return jresult;
23399 }
23400
23401
23402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23403   int jresult ;
23404   int result;
23405
23406   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23407   jresult = (int)result;
23408   return jresult;
23409 }
23410
23411
23412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23413   int jresult ;
23414   int result;
23415
23416   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23417   jresult = (int)result;
23418   return jresult;
23419 }
23420
23421
23422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23423   int jresult ;
23424   int result;
23425
23426   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23427   jresult = (int)result;
23428   return jresult;
23429 }
23430
23431
23432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23433   int jresult ;
23434   int result;
23435
23436   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23437   jresult = (int)result;
23438   return jresult;
23439 }
23440
23441
23442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23443   int jresult ;
23444   int result;
23445
23446   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23447   jresult = (int)result;
23448   return jresult;
23449 }
23450
23451
23452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23453   int jresult ;
23454   int result;
23455
23456   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23457   jresult = (int)result;
23458   return jresult;
23459 }
23460
23461
23462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23463   int jresult ;
23464   int result;
23465
23466   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23467   jresult = (int)result;
23468   return jresult;
23469 }
23470
23471
23472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23473   int jresult ;
23474   int result;
23475
23476   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23477   jresult = (int)result;
23478   return jresult;
23479 }
23480
23481
23482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23483   int jresult ;
23484   int result;
23485
23486   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23487   jresult = (int)result;
23488   return jresult;
23489 }
23490
23491
23492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23493   int jresult ;
23494   int result;
23495
23496   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23497   jresult = (int)result;
23498   return jresult;
23499 }
23500
23501
23502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23503   int jresult ;
23504   int result;
23505
23506   result = (int)Dali::Renderer::Property::RENDER_MODE;
23507   jresult = (int)result;
23508   return jresult;
23509 }
23510
23511
23512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23513   int jresult ;
23514   int result;
23515
23516   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23517   jresult = (int)result;
23518   return jresult;
23519 }
23520
23521
23522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23523   int jresult ;
23524   int result;
23525
23526   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23527   jresult = (int)result;
23528   return jresult;
23529 }
23530
23531
23532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23533   int jresult ;
23534   int result;
23535
23536   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23537   jresult = (int)result;
23538   return jresult;
23539 }
23540
23541
23542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23543   int jresult ;
23544   int result;
23545
23546   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23547   jresult = (int)result;
23548   return jresult;
23549 }
23550
23551
23552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23553   int jresult ;
23554   int result;
23555
23556   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23557   jresult = (int)result;
23558   return jresult;
23559 }
23560
23561
23562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23563   int jresult ;
23564   int result;
23565
23566   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23567   jresult = (int)result;
23568   return jresult;
23569 }
23570
23571
23572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23573   int jresult ;
23574   int result;
23575
23576   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23577   jresult = (int)result;
23578   return jresult;
23579 }
23580
23581
23582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23583   void * jresult ;
23584   Dali::Renderer::Property *result = 0 ;
23585
23586   {
23587     try {
23588       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23589     } catch (std::out_of_range& e) {
23590       {
23591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23592       };
23593     } catch (std::exception& e) {
23594       {
23595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23596       };
23597     } catch (...) {
23598       {
23599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23600       };
23601     }
23602   }
23603   jresult = (void *)result;
23604   return jresult;
23605 }
23606
23607
23608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23609   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23610
23611   arg1 = (Dali::Renderer::Property *)jarg1;
23612   {
23613     try {
23614       delete arg1;
23615     } catch (std::out_of_range& e) {
23616       {
23617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23618       };
23619     } catch (std::exception& e) {
23620       {
23621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23622       };
23623     } catch (...) {
23624       {
23625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23626       };
23627     }
23628   }
23629 }
23630
23631
23632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23633   void * jresult ;
23634   Dali::Geometry *arg1 = 0 ;
23635   Dali::Shader *arg2 = 0 ;
23636   Dali::Renderer result;
23637
23638   arg1 = (Dali::Geometry *)jarg1;
23639   if (!arg1) {
23640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23641     return 0;
23642   }
23643   arg2 = (Dali::Shader *)jarg2;
23644   if (!arg2) {
23645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23646     return 0;
23647   }
23648   {
23649     try {
23650       result = Dali::Renderer::New(*arg1,*arg2);
23651     } catch (std::out_of_range& e) {
23652       {
23653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23654       };
23655     } catch (std::exception& e) {
23656       {
23657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23658       };
23659     } catch (...) {
23660       {
23661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23662       };
23663     }
23664   }
23665   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23666   return jresult;
23667 }
23668
23669
23670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23671   void * jresult ;
23672   Dali::Renderer *result = 0 ;
23673
23674   {
23675     try {
23676       result = (Dali::Renderer *)new Dali::Renderer();
23677     } catch (std::out_of_range& e) {
23678       {
23679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23680       };
23681     } catch (std::exception& e) {
23682       {
23683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23684       };
23685     } catch (...) {
23686       {
23687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23688       };
23689     }
23690   }
23691   jresult = (void *)result;
23692   return jresult;
23693 }
23694
23695
23696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23697   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23698
23699   arg1 = (Dali::Renderer *)jarg1;
23700   {
23701     try {
23702       delete arg1;
23703     } catch (std::out_of_range& e) {
23704       {
23705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23706       };
23707     } catch (std::exception& e) {
23708       {
23709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23710       };
23711     } catch (...) {
23712       {
23713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23714       };
23715     }
23716   }
23717 }
23718
23719
23720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23721   void * jresult ;
23722   Dali::Renderer *arg1 = 0 ;
23723   Dali::Renderer *result = 0 ;
23724
23725   arg1 = (Dali::Renderer *)jarg1;
23726   if (!arg1) {
23727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23728     return 0;
23729   }
23730   {
23731     try {
23732       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23733     } catch (std::out_of_range& e) {
23734       {
23735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23736       };
23737     } catch (std::exception& e) {
23738       {
23739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23740       };
23741     } catch (...) {
23742       {
23743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23744       };
23745     }
23746   }
23747   jresult = (void *)result;
23748   return jresult;
23749 }
23750
23751
23752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23753   void * jresult ;
23754   Dali::BaseHandle arg1 ;
23755   Dali::BaseHandle *argp1 ;
23756   Dali::Renderer result;
23757
23758   argp1 = (Dali::BaseHandle *)jarg1;
23759   if (!argp1) {
23760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23761     return 0;
23762   }
23763   arg1 = *argp1;
23764   {
23765     try {
23766       result = Dali::Renderer::DownCast(arg1);
23767     } catch (std::out_of_range& e) {
23768       {
23769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23770       };
23771     } catch (std::exception& e) {
23772       {
23773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23774       };
23775     } catch (...) {
23776       {
23777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23778       };
23779     }
23780   }
23781   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23782   return jresult;
23783 }
23784
23785
23786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23787   void * jresult ;
23788   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23789   Dali::Renderer *arg2 = 0 ;
23790   Dali::Renderer *result = 0 ;
23791
23792   arg1 = (Dali::Renderer *)jarg1;
23793   arg2 = (Dali::Renderer *)jarg2;
23794   if (!arg2) {
23795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23796     return 0;
23797   }
23798   {
23799     try {
23800       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23801     } catch (std::out_of_range& e) {
23802       {
23803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23804       };
23805     } catch (std::exception& e) {
23806       {
23807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23808       };
23809     } catch (...) {
23810       {
23811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23812       };
23813     }
23814   }
23815   jresult = (void *)result;
23816   return jresult;
23817 }
23818
23819
23820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23821   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23822   Dali::Geometry *arg2 = 0 ;
23823
23824   arg1 = (Dali::Renderer *)jarg1;
23825   arg2 = (Dali::Geometry *)jarg2;
23826   if (!arg2) {
23827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23828     return ;
23829   }
23830   {
23831     try {
23832       (arg1)->SetGeometry(*arg2);
23833     } catch (std::out_of_range& e) {
23834       {
23835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23836       };
23837     } catch (std::exception& e) {
23838       {
23839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23840       };
23841     } catch (...) {
23842       {
23843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23844       };
23845     }
23846   }
23847 }
23848
23849
23850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23851   void * jresult ;
23852   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23853   Dali::Geometry result;
23854
23855   arg1 = (Dali::Renderer *)jarg1;
23856   {
23857     try {
23858       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23859     } catch (std::out_of_range& e) {
23860       {
23861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23862       };
23863     } catch (std::exception& e) {
23864       {
23865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23866       };
23867     } catch (...) {
23868       {
23869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23870       };
23871     }
23872   }
23873   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23874   return jresult;
23875 }
23876
23877
23878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23879   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23880   int arg2 ;
23881   int arg3 ;
23882
23883   arg1 = (Dali::Renderer *)jarg1;
23884   arg2 = (int)jarg2;
23885   arg3 = (int)jarg3;
23886   {
23887     try {
23888       (arg1)->SetIndexRange(arg2,arg3);
23889     } catch (std::out_of_range& e) {
23890       {
23891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23892       };
23893     } catch (std::exception& e) {
23894       {
23895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23896       };
23897     } catch (...) {
23898       {
23899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23900       };
23901     }
23902   }
23903 }
23904
23905
23906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23907   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23908   Dali::TextureSet *arg2 = 0 ;
23909
23910   arg1 = (Dali::Renderer *)jarg1;
23911   arg2 = (Dali::TextureSet *)jarg2;
23912   if (!arg2) {
23913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23914     return ;
23915   }
23916   {
23917     try {
23918       (arg1)->SetTextures(*arg2);
23919     } catch (std::out_of_range& e) {
23920       {
23921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23922       };
23923     } catch (std::exception& e) {
23924       {
23925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23926       };
23927     } catch (...) {
23928       {
23929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23930       };
23931     }
23932   }
23933 }
23934
23935
23936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23937   void * jresult ;
23938   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23939   Dali::TextureSet result;
23940
23941   arg1 = (Dali::Renderer *)jarg1;
23942   {
23943     try {
23944       result = ((Dali::Renderer const *)arg1)->GetTextures();
23945     } catch (std::out_of_range& e) {
23946       {
23947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23948       };
23949     } catch (std::exception& e) {
23950       {
23951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23952       };
23953     } catch (...) {
23954       {
23955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23956       };
23957     }
23958   }
23959   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23960   return jresult;
23961 }
23962
23963
23964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23965   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23966   Dali::Shader *arg2 = 0 ;
23967
23968   arg1 = (Dali::Renderer *)jarg1;
23969   arg2 = (Dali::Shader *)jarg2;
23970   if (!arg2) {
23971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23972     return ;
23973   }
23974   {
23975     try {
23976       (arg1)->SetShader(*arg2);
23977     } catch (std::out_of_range& e) {
23978       {
23979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23980       };
23981     } catch (std::exception& e) {
23982       {
23983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23984       };
23985     } catch (...) {
23986       {
23987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23988       };
23989     }
23990   }
23991 }
23992
23993
23994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
23995   void * jresult ;
23996   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23997   Dali::Shader result;
23998
23999   arg1 = (Dali::Renderer *)jarg1;
24000   {
24001     try {
24002       result = ((Dali::Renderer const *)arg1)->GetShader();
24003     } catch (std::out_of_range& e) {
24004       {
24005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24006       };
24007     } catch (std::exception& e) {
24008       {
24009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24010       };
24011     } catch (...) {
24012       {
24013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24014       };
24015     }
24016   }
24017   jresult = new Dali::Shader((const Dali::Shader &)result);
24018   return jresult;
24019 }
24020
24021
24022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24023   void * jresult ;
24024   Dali::FrameBuffer::Attachment *result = 0 ;
24025
24026   {
24027     try {
24028       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24029     } catch (std::out_of_range& e) {
24030       {
24031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24032       };
24033     } catch (std::exception& e) {
24034       {
24035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24036       };
24037     } catch (...) {
24038       {
24039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24040       };
24041     }
24042   }
24043   jresult = (void *)result;
24044   return jresult;
24045 }
24046
24047
24048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24049   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24050
24051   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24052   {
24053     try {
24054       delete arg1;
24055     } catch (std::out_of_range& e) {
24056       {
24057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24058       };
24059     } catch (std::exception& e) {
24060       {
24061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24062       };
24063     } catch (...) {
24064       {
24065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24066       };
24067     }
24068   }
24069 }
24070
24071
24072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24073   void * jresult ;
24074   unsigned int arg1 ;
24075   unsigned int arg2 ;
24076   unsigned int arg3 ;
24077   Dali::FrameBuffer result;
24078
24079   arg1 = (unsigned int)jarg1;
24080   arg2 = (unsigned int)jarg2;
24081   arg3 = (unsigned int)jarg3;
24082   {
24083     try {
24084       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24085     } catch (std::out_of_range& e) {
24086       {
24087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24088       };
24089     } catch (std::exception& e) {
24090       {
24091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24092       };
24093     } catch (...) {
24094       {
24095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24096       };
24097     }
24098   }
24099   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24100   return jresult;
24101 }
24102
24103
24104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24105   void * jresult ;
24106   Dali::FrameBuffer *result = 0 ;
24107
24108   {
24109     try {
24110       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24111     } catch (std::out_of_range& e) {
24112       {
24113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24114       };
24115     } catch (std::exception& e) {
24116       {
24117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24118       };
24119     } catch (...) {
24120       {
24121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24122       };
24123     }
24124   }
24125   jresult = (void *)result;
24126   return jresult;
24127 }
24128
24129
24130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24131   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24132
24133   arg1 = (Dali::FrameBuffer *)jarg1;
24134   {
24135     try {
24136       delete arg1;
24137     } catch (std::out_of_range& e) {
24138       {
24139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24140       };
24141     } catch (std::exception& e) {
24142       {
24143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24144       };
24145     } catch (...) {
24146       {
24147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24148       };
24149     }
24150   }
24151 }
24152
24153
24154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24155   void * jresult ;
24156   Dali::FrameBuffer *arg1 = 0 ;
24157   Dali::FrameBuffer *result = 0 ;
24158
24159   arg1 = (Dali::FrameBuffer *)jarg1;
24160   if (!arg1) {
24161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24162     return 0;
24163   }
24164   {
24165     try {
24166       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24167     } catch (std::out_of_range& e) {
24168       {
24169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24170       };
24171     } catch (std::exception& e) {
24172       {
24173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24174       };
24175     } catch (...) {
24176       {
24177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24178       };
24179     }
24180   }
24181   jresult = (void *)result;
24182   return jresult;
24183 }
24184
24185
24186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24187   void * jresult ;
24188   Dali::BaseHandle arg1 ;
24189   Dali::BaseHandle *argp1 ;
24190   Dali::FrameBuffer result;
24191
24192   argp1 = (Dali::BaseHandle *)jarg1;
24193   if (!argp1) {
24194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24195     return 0;
24196   }
24197   arg1 = *argp1;
24198   {
24199     try {
24200       result = Dali::FrameBuffer::DownCast(arg1);
24201     } catch (std::out_of_range& e) {
24202       {
24203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24204       };
24205     } catch (std::exception& e) {
24206       {
24207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24208       };
24209     } catch (...) {
24210       {
24211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24212       };
24213     }
24214   }
24215   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24216   return jresult;
24217 }
24218
24219
24220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24221   void * jresult ;
24222   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24223   Dali::FrameBuffer *arg2 = 0 ;
24224   Dali::FrameBuffer *result = 0 ;
24225
24226   arg1 = (Dali::FrameBuffer *)jarg1;
24227   arg2 = (Dali::FrameBuffer *)jarg2;
24228   if (!arg2) {
24229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24230     return 0;
24231   }
24232   {
24233     try {
24234       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24235     } catch (std::out_of_range& e) {
24236       {
24237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24238       };
24239     } catch (std::exception& e) {
24240       {
24241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24242       };
24243     } catch (...) {
24244       {
24245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24246       };
24247     }
24248   }
24249   jresult = (void *)result;
24250   return jresult;
24251 }
24252
24253
24254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24255   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24256   Dali::Texture *arg2 = 0 ;
24257
24258   arg1 = (Dali::FrameBuffer *)jarg1;
24259   arg2 = (Dali::Texture *)jarg2;
24260   if (!arg2) {
24261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24262     return ;
24263   }
24264   {
24265     try {
24266       (arg1)->AttachColorTexture(*arg2);
24267     } catch (std::out_of_range& e) {
24268       {
24269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24270       };
24271     } catch (std::exception& e) {
24272       {
24273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24274       };
24275     } catch (...) {
24276       {
24277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24278       };
24279     }
24280   }
24281 }
24282
24283
24284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24285   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24286   Dali::Texture *arg2 = 0 ;
24287   unsigned int arg3 ;
24288   unsigned int arg4 ;
24289
24290   arg1 = (Dali::FrameBuffer *)jarg1;
24291   arg2 = (Dali::Texture *)jarg2;
24292   if (!arg2) {
24293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24294     return ;
24295   }
24296   arg3 = (unsigned int)jarg3;
24297   arg4 = (unsigned int)jarg4;
24298   {
24299     try {
24300       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24301     } catch (std::out_of_range& e) {
24302       {
24303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24304       };
24305     } catch (std::exception& e) {
24306       {
24307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24308       };
24309     } catch (...) {
24310       {
24311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24312       };
24313     }
24314   }
24315 }
24316
24317
24318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24319   void * jresult ;
24320   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24321   Dali::Texture result;
24322
24323   arg1 = (Dali::FrameBuffer *)jarg1;
24324   {
24325     try {
24326       result = (arg1)->GetColorTexture();
24327     } catch (std::out_of_range& e) {
24328       {
24329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24330       };
24331     } catch (std::exception& e) {
24332       {
24333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24334       };
24335     } catch (...) {
24336       {
24337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24338       };
24339     }
24340   }
24341   jresult = new Dali::Texture((const Dali::Texture &)result);
24342   return jresult;
24343 }
24344
24345
24346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24347   void * jresult ;
24348   Dali::RenderTaskList *result = 0 ;
24349
24350   {
24351     try {
24352       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24353     } catch (std::out_of_range& e) {
24354       {
24355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24356       };
24357     } catch (std::exception& e) {
24358       {
24359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24360       };
24361     } catch (...) {
24362       {
24363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24364       };
24365     }
24366   }
24367   jresult = (void *)result;
24368   return jresult;
24369 }
24370
24371
24372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24373   void * jresult ;
24374   Dali::BaseHandle arg1 ;
24375   Dali::BaseHandle *argp1 ;
24376   Dali::RenderTaskList result;
24377
24378   argp1 = (Dali::BaseHandle *)jarg1;
24379   if (!argp1) {
24380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24381     return 0;
24382   }
24383   arg1 = *argp1;
24384   {
24385     try {
24386       result = Dali::RenderTaskList::DownCast(arg1);
24387     } catch (std::out_of_range& e) {
24388       {
24389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24390       };
24391     } catch (std::exception& e) {
24392       {
24393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24394       };
24395     } catch (...) {
24396       {
24397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24398       };
24399     }
24400   }
24401   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24402   return jresult;
24403 }
24404
24405
24406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24407   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24408
24409   arg1 = (Dali::RenderTaskList *)jarg1;
24410   {
24411     try {
24412       delete arg1;
24413     } catch (std::out_of_range& e) {
24414       {
24415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24416       };
24417     } catch (std::exception& e) {
24418       {
24419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24420       };
24421     } catch (...) {
24422       {
24423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24424       };
24425     }
24426   }
24427 }
24428
24429
24430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24431   void * jresult ;
24432   Dali::RenderTaskList *arg1 = 0 ;
24433   Dali::RenderTaskList *result = 0 ;
24434
24435   arg1 = (Dali::RenderTaskList *)jarg1;
24436   if (!arg1) {
24437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24438     return 0;
24439   }
24440   {
24441     try {
24442       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24443     } catch (std::out_of_range& e) {
24444       {
24445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24446       };
24447     } catch (std::exception& e) {
24448       {
24449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24450       };
24451     } catch (...) {
24452       {
24453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24454       };
24455     }
24456   }
24457   jresult = (void *)result;
24458   return jresult;
24459 }
24460
24461
24462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24463   void * jresult ;
24464   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24465   Dali::RenderTaskList *arg2 = 0 ;
24466   Dali::RenderTaskList *result = 0 ;
24467
24468   arg1 = (Dali::RenderTaskList *)jarg1;
24469   arg2 = (Dali::RenderTaskList *)jarg2;
24470   if (!arg2) {
24471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24472     return 0;
24473   }
24474   {
24475     try {
24476       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24477     } catch (std::out_of_range& e) {
24478       {
24479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24480       };
24481     } catch (std::exception& e) {
24482       {
24483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24484       };
24485     } catch (...) {
24486       {
24487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24488       };
24489     }
24490   }
24491   jresult = (void *)result;
24492   return jresult;
24493 }
24494
24495
24496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24497   void * jresult ;
24498   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24499   Dali::RenderTask result;
24500
24501   arg1 = (Dali::RenderTaskList *)jarg1;
24502   {
24503     try {
24504       result = (arg1)->CreateTask();
24505     } catch (std::out_of_range& e) {
24506       {
24507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24508       };
24509     } catch (std::exception& e) {
24510       {
24511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24512       };
24513     } catch (...) {
24514       {
24515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24516       };
24517     }
24518   }
24519   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24520   return jresult;
24521 }
24522
24523
24524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24525   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24526   Dali::RenderTask arg2 ;
24527   Dali::RenderTask *argp2 ;
24528
24529   arg1 = (Dali::RenderTaskList *)jarg1;
24530   argp2 = (Dali::RenderTask *)jarg2;
24531   if (!argp2) {
24532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24533     return ;
24534   }
24535   arg2 = *argp2;
24536   {
24537     try {
24538       (arg1)->RemoveTask(arg2);
24539     } catch (std::out_of_range& e) {
24540       {
24541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24542       };
24543     } catch (std::exception& e) {
24544       {
24545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24546       };
24547     } catch (...) {
24548       {
24549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24550       };
24551     }
24552   }
24553 }
24554
24555
24556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24557   unsigned int jresult ;
24558   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24559   unsigned int result;
24560
24561   arg1 = (Dali::RenderTaskList *)jarg1;
24562   {
24563     try {
24564       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24565     } catch (std::out_of_range& e) {
24566       {
24567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24568       };
24569     } catch (std::exception& e) {
24570       {
24571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24572       };
24573     } catch (...) {
24574       {
24575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24576       };
24577     }
24578   }
24579   jresult = result;
24580   return jresult;
24581 }
24582
24583
24584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24585   void * jresult ;
24586   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24587   unsigned int arg2 ;
24588   Dali::RenderTask result;
24589
24590   arg1 = (Dali::RenderTaskList *)jarg1;
24591   arg2 = (unsigned int)jarg2;
24592   {
24593     try {
24594       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24595     } catch (std::out_of_range& e) {
24596       {
24597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24598       };
24599     } catch (std::exception& e) {
24600       {
24601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24602       };
24603     } catch (...) {
24604       {
24605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24606       };
24607     }
24608   }
24609   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24610   return jresult;
24611 }
24612
24613
24614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24615   int jresult ;
24616   int result;
24617
24618   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24619   jresult = (int)result;
24620   return jresult;
24621 }
24622
24623
24624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24625   int jresult ;
24626   int result;
24627
24628   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24629   jresult = (int)result;
24630   return jresult;
24631 }
24632
24633
24634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24635   int jresult ;
24636   int result;
24637
24638   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24639   jresult = (int)result;
24640   return jresult;
24641 }
24642
24643
24644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24645   int jresult ;
24646   int result;
24647
24648   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24649   jresult = (int)result;
24650   return jresult;
24651 }
24652
24653
24654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24655   void * jresult ;
24656   Dali::RenderTask::Property *result = 0 ;
24657
24658   {
24659     try {
24660       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24661     } catch (std::out_of_range& e) {
24662       {
24663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24664       };
24665     } catch (std::exception& e) {
24666       {
24667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24668       };
24669     } catch (...) {
24670       {
24671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24672       };
24673     }
24674   }
24675   jresult = (void *)result;
24676   return jresult;
24677 }
24678
24679
24680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24681   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24682
24683   arg1 = (Dali::RenderTask::Property *)jarg1;
24684   {
24685     try {
24686       delete arg1;
24687     } catch (std::out_of_range& e) {
24688       {
24689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24690       };
24691     } catch (std::exception& e) {
24692       {
24693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24694       };
24695     } catch (...) {
24696       {
24697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24698       };
24699     }
24700   }
24701 }
24702
24703
24704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24705   void * jresult ;
24706   bool (*result)(Dali::Vector2 &) = 0 ;
24707
24708   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24709   jresult = (void *)result;
24710   return jresult;
24711 }
24712
24713
24714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24715   void * jresult ;
24716   bool (*result)(Dali::Vector2 &) = 0 ;
24717
24718   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24719   jresult = (void *)result;
24720   return jresult;
24721 }
24722
24723
24724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24725   unsigned int jresult ;
24726   bool result;
24727
24728   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24729   jresult = result;
24730   return jresult;
24731 }
24732
24733
24734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24735   unsigned int jresult ;
24736   bool result;
24737
24738   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24739   jresult = result;
24740   return jresult;
24741 }
24742
24743
24744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24745   void * jresult ;
24746   Dali::Vector4 *result = 0 ;
24747
24748   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24749   jresult = (void *)result;
24750   return jresult;
24751 }
24752
24753
24754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24755   unsigned int jresult ;
24756   bool result;
24757
24758   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24759   jresult = result;
24760   return jresult;
24761 }
24762
24763
24764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24765   unsigned int jresult ;
24766   bool result;
24767
24768   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24769   jresult = result;
24770   return jresult;
24771 }
24772
24773
24774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24775   unsigned int jresult ;
24776   unsigned int result;
24777
24778   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24779   jresult = result;
24780   return jresult;
24781 }
24782
24783
24784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24785   void * jresult ;
24786   Dali::RenderTask *result = 0 ;
24787
24788   {
24789     try {
24790       result = (Dali::RenderTask *)new Dali::RenderTask();
24791     } catch (std::out_of_range& e) {
24792       {
24793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24794       };
24795     } catch (std::exception& e) {
24796       {
24797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24798       };
24799     } catch (...) {
24800       {
24801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24802       };
24803     }
24804   }
24805   jresult = (void *)result;
24806   return jresult;
24807 }
24808
24809
24810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24811   void * jresult ;
24812   Dali::BaseHandle arg1 ;
24813   Dali::BaseHandle *argp1 ;
24814   Dali::RenderTask result;
24815
24816   argp1 = (Dali::BaseHandle *)jarg1;
24817   if (!argp1) {
24818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24819     return 0;
24820   }
24821   arg1 = *argp1;
24822   {
24823     try {
24824       result = Dali::RenderTask::DownCast(arg1);
24825     } catch (std::out_of_range& e) {
24826       {
24827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24828       };
24829     } catch (std::exception& e) {
24830       {
24831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24832       };
24833     } catch (...) {
24834       {
24835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24836       };
24837     }
24838   }
24839   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24840   return jresult;
24841 }
24842
24843
24844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24845   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24846
24847   arg1 = (Dali::RenderTask *)jarg1;
24848   {
24849     try {
24850       delete arg1;
24851     } catch (std::out_of_range& e) {
24852       {
24853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24854       };
24855     } catch (std::exception& e) {
24856       {
24857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24858       };
24859     } catch (...) {
24860       {
24861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24862       };
24863     }
24864   }
24865 }
24866
24867
24868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24869   void * jresult ;
24870   Dali::RenderTask *arg1 = 0 ;
24871   Dali::RenderTask *result = 0 ;
24872
24873   arg1 = (Dali::RenderTask *)jarg1;
24874   if (!arg1) {
24875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24876     return 0;
24877   }
24878   {
24879     try {
24880       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24881     } catch (std::out_of_range& e) {
24882       {
24883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24884       };
24885     } catch (std::exception& e) {
24886       {
24887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24888       };
24889     } catch (...) {
24890       {
24891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24892       };
24893     }
24894   }
24895   jresult = (void *)result;
24896   return jresult;
24897 }
24898
24899
24900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24901   void * jresult ;
24902   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24903   Dali::RenderTask *arg2 = 0 ;
24904   Dali::RenderTask *result = 0 ;
24905
24906   arg1 = (Dali::RenderTask *)jarg1;
24907   arg2 = (Dali::RenderTask *)jarg2;
24908   if (!arg2) {
24909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24910     return 0;
24911   }
24912   {
24913     try {
24914       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24915     } catch (std::out_of_range& e) {
24916       {
24917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24918       };
24919     } catch (std::exception& e) {
24920       {
24921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24922       };
24923     } catch (...) {
24924       {
24925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24926       };
24927     }
24928   }
24929   jresult = (void *)result;
24930   return jresult;
24931 }
24932
24933
24934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24935   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24936   Dali::Actor arg2 ;
24937   Dali::Actor *argp2 ;
24938
24939   arg1 = (Dali::RenderTask *)jarg1;
24940   argp2 = (Dali::Actor *)jarg2;
24941   if (!argp2) {
24942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24943     return ;
24944   }
24945   arg2 = *argp2;
24946   {
24947     try {
24948       (arg1)->SetSourceActor(arg2);
24949     } catch (std::out_of_range& e) {
24950       {
24951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24952       };
24953     } catch (std::exception& e) {
24954       {
24955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24956       };
24957     } catch (...) {
24958       {
24959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24960       };
24961     }
24962   }
24963 }
24964
24965
24966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24967   void * jresult ;
24968   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24969   Dali::Actor result;
24970
24971   arg1 = (Dali::RenderTask *)jarg1;
24972   {
24973     try {
24974       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24975     } catch (std::out_of_range& e) {
24976       {
24977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24978       };
24979     } catch (std::exception& e) {
24980       {
24981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24982       };
24983     } catch (...) {
24984       {
24985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24986       };
24987     }
24988   }
24989   jresult = new Dali::Actor((const Dali::Actor &)result);
24990   return jresult;
24991 }
24992
24993
24994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
24995   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24996   bool arg2 ;
24997
24998   arg1 = (Dali::RenderTask *)jarg1;
24999   arg2 = jarg2 ? true : false;
25000   {
25001     try {
25002       (arg1)->SetExclusive(arg2);
25003     } catch (std::out_of_range& e) {
25004       {
25005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25006       };
25007     } catch (std::exception& e) {
25008       {
25009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25010       };
25011     } catch (...) {
25012       {
25013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25014       };
25015     }
25016   }
25017 }
25018
25019
25020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25021   unsigned int jresult ;
25022   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25023   bool result;
25024
25025   arg1 = (Dali::RenderTask *)jarg1;
25026   {
25027     try {
25028       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25029     } catch (std::out_of_range& e) {
25030       {
25031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25032       };
25033     } catch (std::exception& e) {
25034       {
25035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25036       };
25037     } catch (...) {
25038       {
25039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25040       };
25041     }
25042   }
25043   jresult = result;
25044   return jresult;
25045 }
25046
25047
25048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25049   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25050   bool arg2 ;
25051
25052   arg1 = (Dali::RenderTask *)jarg1;
25053   arg2 = jarg2 ? true : false;
25054   {
25055     try {
25056       (arg1)->SetInputEnabled(arg2);
25057     } catch (std::out_of_range& e) {
25058       {
25059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25060       };
25061     } catch (std::exception& e) {
25062       {
25063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25064       };
25065     } catch (...) {
25066       {
25067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25068       };
25069     }
25070   }
25071 }
25072
25073
25074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25075   unsigned int jresult ;
25076   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25077   bool result;
25078
25079   arg1 = (Dali::RenderTask *)jarg1;
25080   {
25081     try {
25082       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25083     } catch (std::out_of_range& e) {
25084       {
25085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25086       };
25087     } catch (std::exception& e) {
25088       {
25089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25090       };
25091     } catch (...) {
25092       {
25093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25094       };
25095     }
25096   }
25097   jresult = result;
25098   return jresult;
25099 }
25100
25101
25102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25103   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25104   Dali::CameraActor arg2 ;
25105   Dali::CameraActor *argp2 ;
25106
25107   arg1 = (Dali::RenderTask *)jarg1;
25108   argp2 = (Dali::CameraActor *)jarg2;
25109   if (!argp2) {
25110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25111     return ;
25112   }
25113   arg2 = *argp2;
25114   {
25115     try {
25116       (arg1)->SetCameraActor(arg2);
25117     } catch (std::out_of_range& e) {
25118       {
25119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25120       };
25121     } catch (std::exception& e) {
25122       {
25123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25124       };
25125     } catch (...) {
25126       {
25127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25128       };
25129     }
25130   }
25131 }
25132
25133
25134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25135   void * jresult ;
25136   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25137   Dali::CameraActor result;
25138
25139   arg1 = (Dali::RenderTask *)jarg1;
25140   {
25141     try {
25142       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25143     } catch (std::out_of_range& e) {
25144       {
25145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25146       };
25147     } catch (std::exception& e) {
25148       {
25149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25150       };
25151     } catch (...) {
25152       {
25153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25154       };
25155     }
25156   }
25157   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25158   return jresult;
25159 }
25160
25161
25162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25163   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25164   Dali::FrameBufferImage arg2 ;
25165   Dali::FrameBufferImage *argp2 ;
25166
25167   arg1 = (Dali::RenderTask *)jarg1;
25168   argp2 = (Dali::FrameBufferImage *)jarg2;
25169   if (!argp2) {
25170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25171     return ;
25172   }
25173   arg2 = *argp2;
25174   {
25175     try {
25176       (arg1)->SetTargetFrameBuffer(arg2);
25177     } catch (std::out_of_range& e) {
25178       {
25179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25180       };
25181     } catch (std::exception& e) {
25182       {
25183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25184       };
25185     } catch (...) {
25186       {
25187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25188       };
25189     }
25190   }
25191 }
25192
25193
25194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25195   void * jresult ;
25196   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25197   Dali::FrameBufferImage result;
25198
25199   arg1 = (Dali::RenderTask *)jarg1;
25200   {
25201     try {
25202       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25203     } catch (std::out_of_range& e) {
25204       {
25205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25206       };
25207     } catch (std::exception& e) {
25208       {
25209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25210       };
25211     } catch (...) {
25212       {
25213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25214       };
25215     }
25216   }
25217   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25218   return jresult;
25219 }
25220
25221
25222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25223   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25224   Dali::FrameBuffer arg2 ;
25225   Dali::FrameBuffer *argp2 ;
25226
25227   arg1 = (Dali::RenderTask *)jarg1;
25228   argp2 = (Dali::FrameBuffer *)jarg2;
25229   if (!argp2) {
25230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25231     return ;
25232   }
25233   arg2 = *argp2;
25234   {
25235     try {
25236       (arg1)->SetFrameBuffer(arg2);
25237     } catch (std::out_of_range& e) {
25238       {
25239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25240       };
25241     } catch (std::exception& e) {
25242       {
25243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25244       };
25245     } catch (...) {
25246       {
25247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25248       };
25249     }
25250   }
25251 }
25252
25253
25254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25255   void * jresult ;
25256   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25257   Dali::FrameBuffer result;
25258
25259   arg1 = (Dali::RenderTask *)jarg1;
25260   {
25261     try {
25262       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25263     } catch (std::out_of_range& e) {
25264       {
25265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25266       };
25267     } catch (std::exception& e) {
25268       {
25269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25270       };
25271     } catch (...) {
25272       {
25273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25274       };
25275     }
25276   }
25277   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25278   return jresult;
25279 }
25280
25281
25282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25283   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25284   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25285
25286   arg1 = (Dali::RenderTask *)jarg1;
25287   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25288   {
25289     try {
25290       (arg1)->SetScreenToFrameBufferFunction(arg2);
25291     } catch (std::out_of_range& e) {
25292       {
25293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25294       };
25295     } catch (std::exception& e) {
25296       {
25297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25298       };
25299     } catch (...) {
25300       {
25301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25302       };
25303     }
25304   }
25305 }
25306
25307
25308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25309   void * jresult ;
25310   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25311   Dali::RenderTask::ScreenToFrameBufferFunction result;
25312
25313   arg1 = (Dali::RenderTask *)jarg1;
25314   {
25315     try {
25316       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25317     } catch (std::out_of_range& e) {
25318       {
25319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25320       };
25321     } catch (std::exception& e) {
25322       {
25323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25324       };
25325     } catch (...) {
25326       {
25327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25328       };
25329     }
25330   }
25331   jresult = (void *)result;
25332   return jresult;
25333 }
25334
25335
25336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25337   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25338   Dali::Actor arg2 ;
25339   Dali::Actor *argp2 ;
25340
25341   arg1 = (Dali::RenderTask *)jarg1;
25342   argp2 = (Dali::Actor *)jarg2;
25343   if (!argp2) {
25344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25345     return ;
25346   }
25347   arg2 = *argp2;
25348   {
25349     try {
25350       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25351     } catch (std::out_of_range& e) {
25352       {
25353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25354       };
25355     } catch (std::exception& e) {
25356       {
25357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25358       };
25359     } catch (...) {
25360       {
25361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25362       };
25363     }
25364   }
25365 }
25366
25367
25368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25369   void * jresult ;
25370   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25371   Dali::Actor result;
25372
25373   arg1 = (Dali::RenderTask *)jarg1;
25374   {
25375     try {
25376       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25377     } catch (std::out_of_range& e) {
25378       {
25379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25380       };
25381     } catch (std::exception& e) {
25382       {
25383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25384       };
25385     } catch (...) {
25386       {
25387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25388       };
25389     }
25390   }
25391   jresult = new Dali::Actor((const Dali::Actor &)result);
25392   return jresult;
25393 }
25394
25395
25396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25397   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25398   Dali::Vector2 arg2 ;
25399   Dali::Vector2 *argp2 ;
25400
25401   arg1 = (Dali::RenderTask *)jarg1;
25402   argp2 = (Dali::Vector2 *)jarg2;
25403   if (!argp2) {
25404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25405     return ;
25406   }
25407   arg2 = *argp2;
25408   {
25409     try {
25410       (arg1)->SetViewportPosition(arg2);
25411     } catch (std::out_of_range& e) {
25412       {
25413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25414       };
25415     } catch (std::exception& e) {
25416       {
25417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25418       };
25419     } catch (...) {
25420       {
25421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25422       };
25423     }
25424   }
25425 }
25426
25427
25428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25429   void * jresult ;
25430   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25431   Dali::Vector2 result;
25432
25433   arg1 = (Dali::RenderTask *)jarg1;
25434   {
25435     try {
25436       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25437     } catch (std::out_of_range& e) {
25438       {
25439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25440       };
25441     } catch (std::exception& e) {
25442       {
25443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25444       };
25445     } catch (...) {
25446       {
25447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25448       };
25449     }
25450   }
25451   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25452   return jresult;
25453 }
25454
25455
25456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25457   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25458   Dali::Vector2 arg2 ;
25459   Dali::Vector2 *argp2 ;
25460
25461   arg1 = (Dali::RenderTask *)jarg1;
25462   argp2 = (Dali::Vector2 *)jarg2;
25463   if (!argp2) {
25464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25465     return ;
25466   }
25467   arg2 = *argp2;
25468   {
25469     try {
25470       (arg1)->SetViewportSize(arg2);
25471     } catch (std::out_of_range& e) {
25472       {
25473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25474       };
25475     } catch (std::exception& e) {
25476       {
25477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25478       };
25479     } catch (...) {
25480       {
25481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25482       };
25483     }
25484   }
25485 }
25486
25487
25488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25489   void * jresult ;
25490   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25491   Dali::Vector2 result;
25492
25493   arg1 = (Dali::RenderTask *)jarg1;
25494   {
25495     try {
25496       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25497     } catch (std::out_of_range& e) {
25498       {
25499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25500       };
25501     } catch (std::exception& e) {
25502       {
25503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25504       };
25505     } catch (...) {
25506       {
25507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25508       };
25509     }
25510   }
25511   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25512   return jresult;
25513 }
25514
25515
25516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25517   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25518   Dali::Viewport arg2 ;
25519   Dali::Viewport *argp2 ;
25520
25521   arg1 = (Dali::RenderTask *)jarg1;
25522   argp2 = (Dali::Viewport *)jarg2;
25523   if (!argp2) {
25524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25525     return ;
25526   }
25527   arg2 = *argp2;
25528   {
25529     try {
25530       (arg1)->SetViewport(arg2);
25531     } catch (std::out_of_range& e) {
25532       {
25533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25534       };
25535     } catch (std::exception& e) {
25536       {
25537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25538       };
25539     } catch (...) {
25540       {
25541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25542       };
25543     }
25544   }
25545 }
25546
25547
25548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25549   void * jresult ;
25550   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25551   Dali::Viewport result;
25552
25553   arg1 = (Dali::RenderTask *)jarg1;
25554   {
25555     try {
25556       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25557     } catch (std::out_of_range& e) {
25558       {
25559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25560       };
25561     } catch (std::exception& e) {
25562       {
25563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25564       };
25565     } catch (...) {
25566       {
25567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25568       };
25569     }
25570   }
25571   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25572   return jresult;
25573 }
25574
25575
25576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25577   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25578   Dali::Vector4 *arg2 = 0 ;
25579
25580   arg1 = (Dali::RenderTask *)jarg1;
25581   arg2 = (Dali::Vector4 *)jarg2;
25582   if (!arg2) {
25583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25584     return ;
25585   }
25586   {
25587     try {
25588       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25589     } catch (std::out_of_range& e) {
25590       {
25591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25592       };
25593     } catch (std::exception& e) {
25594       {
25595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25596       };
25597     } catch (...) {
25598       {
25599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25600       };
25601     }
25602   }
25603 }
25604
25605
25606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25607   void * jresult ;
25608   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25609   Dali::Vector4 result;
25610
25611   arg1 = (Dali::RenderTask *)jarg1;
25612   {
25613     try {
25614       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25615     } catch (std::out_of_range& e) {
25616       {
25617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25618       };
25619     } catch (std::exception& e) {
25620       {
25621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25622       };
25623     } catch (...) {
25624       {
25625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25626       };
25627     }
25628   }
25629   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25630   return jresult;
25631 }
25632
25633
25634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25635   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25636   bool arg2 ;
25637
25638   arg1 = (Dali::RenderTask *)jarg1;
25639   arg2 = jarg2 ? true : false;
25640   {
25641     try {
25642       (arg1)->SetClearEnabled(arg2);
25643     } catch (std::out_of_range& e) {
25644       {
25645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25646       };
25647     } catch (std::exception& e) {
25648       {
25649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25650       };
25651     } catch (...) {
25652       {
25653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25654       };
25655     }
25656   }
25657 }
25658
25659
25660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25661   unsigned int jresult ;
25662   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25663   bool result;
25664
25665   arg1 = (Dali::RenderTask *)jarg1;
25666   {
25667     try {
25668       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25669     } catch (std::out_of_range& e) {
25670       {
25671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25672       };
25673     } catch (std::exception& e) {
25674       {
25675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25676       };
25677     } catch (...) {
25678       {
25679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25680       };
25681     }
25682   }
25683   jresult = result;
25684   return jresult;
25685 }
25686
25687
25688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25689   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25690   bool arg2 ;
25691
25692   arg1 = (Dali::RenderTask *)jarg1;
25693   arg2 = jarg2 ? true : false;
25694   {
25695     try {
25696       (arg1)->SetCullMode(arg2);
25697     } catch (std::out_of_range& e) {
25698       {
25699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25700       };
25701     } catch (std::exception& e) {
25702       {
25703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25704       };
25705     } catch (...) {
25706       {
25707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25708       };
25709     }
25710   }
25711 }
25712
25713
25714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25715   unsigned int jresult ;
25716   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25717   bool result;
25718
25719   arg1 = (Dali::RenderTask *)jarg1;
25720   {
25721     try {
25722       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25723     } catch (std::out_of_range& e) {
25724       {
25725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25726       };
25727     } catch (std::exception& e) {
25728       {
25729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25730       };
25731     } catch (...) {
25732       {
25733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25734       };
25735     }
25736   }
25737   jresult = result;
25738   return jresult;
25739 }
25740
25741
25742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25743   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25744   unsigned int arg2 ;
25745
25746   arg1 = (Dali::RenderTask *)jarg1;
25747   arg2 = (unsigned int)jarg2;
25748   {
25749     try {
25750       (arg1)->SetRefreshRate(arg2);
25751     } catch (std::out_of_range& e) {
25752       {
25753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25754       };
25755     } catch (std::exception& e) {
25756       {
25757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25758       };
25759     } catch (...) {
25760       {
25761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25762       };
25763     }
25764   }
25765 }
25766
25767
25768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25769   unsigned int jresult ;
25770   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25771   unsigned int result;
25772
25773   arg1 = (Dali::RenderTask *)jarg1;
25774   {
25775     try {
25776       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25777     } catch (std::out_of_range& e) {
25778       {
25779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25780       };
25781     } catch (std::exception& e) {
25782       {
25783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25784       };
25785     } catch (...) {
25786       {
25787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25788       };
25789     }
25790   }
25791   jresult = result;
25792   return jresult;
25793 }
25794
25795
25796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25797   unsigned int jresult ;
25798   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25799   Dali::Vector3 *arg2 = 0 ;
25800   float *arg3 = 0 ;
25801   float *arg4 = 0 ;
25802   bool result;
25803
25804   arg1 = (Dali::RenderTask *)jarg1;
25805   arg2 = (Dali::Vector3 *)jarg2;
25806   if (!arg2) {
25807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25808     return 0;
25809   }
25810   arg3 = (float *)jarg3;
25811   arg4 = (float *)jarg4;
25812   {
25813     try {
25814       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25815     } catch (std::out_of_range& e) {
25816       {
25817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25818       };
25819     } catch (std::exception& e) {
25820       {
25821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25822       };
25823     } catch (...) {
25824       {
25825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25826       };
25827     }
25828   }
25829   jresult = result;
25830   return jresult;
25831 }
25832
25833
25834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25835   unsigned int jresult ;
25836   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25837   Dali::Actor arg2 ;
25838   float arg3 ;
25839   float arg4 ;
25840   float *arg5 = 0 ;
25841   float *arg6 = 0 ;
25842   Dali::Actor *argp2 ;
25843   bool result;
25844
25845   arg1 = (Dali::RenderTask *)jarg1;
25846   argp2 = (Dali::Actor *)jarg2;
25847   if (!argp2) {
25848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25849     return 0;
25850   }
25851   arg2 = *argp2;
25852   arg3 = (float)jarg3;
25853   arg4 = (float)jarg4;
25854   arg5 = (float *)jarg5;
25855   arg6 = (float *)jarg6;
25856   {
25857     try {
25858       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
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 (...) {
25868       {
25869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25870       };
25871     }
25872   }
25873   jresult = result;
25874   return jresult;
25875 }
25876
25877
25878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25879   void * jresult ;
25880   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25881   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25882
25883   arg1 = (Dali::RenderTask *)jarg1;
25884   {
25885     try {
25886       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25887     } catch (std::out_of_range& e) {
25888       {
25889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25890       };
25891     } catch (std::exception& e) {
25892       {
25893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25894       };
25895     } catch (...) {
25896       {
25897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25898       };
25899     }
25900   }
25901   jresult = (void *)result;
25902   return jresult;
25903 }
25904
25905
25906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25907   void * jresult ;
25908   int arg1 ;
25909   Dali::TouchPoint::State arg2 ;
25910   float arg3 ;
25911   float arg4 ;
25912   Dali::TouchPoint *result = 0 ;
25913
25914   arg1 = (int)jarg1;
25915   arg2 = (Dali::TouchPoint::State)jarg2;
25916   arg3 = (float)jarg3;
25917   arg4 = (float)jarg4;
25918   {
25919     try {
25920       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25921     } catch (std::out_of_range& e) {
25922       {
25923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25924       };
25925     } catch (std::exception& e) {
25926       {
25927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25928       };
25929     } catch (...) {
25930       {
25931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25932       };
25933     }
25934   }
25935   jresult = (void *)result;
25936   return jresult;
25937 }
25938
25939
25940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25941   void * jresult ;
25942   int arg1 ;
25943   Dali::TouchPoint::State arg2 ;
25944   float arg3 ;
25945   float arg4 ;
25946   float arg5 ;
25947   float arg6 ;
25948   Dali::TouchPoint *result = 0 ;
25949
25950   arg1 = (int)jarg1;
25951   arg2 = (Dali::TouchPoint::State)jarg2;
25952   arg3 = (float)jarg3;
25953   arg4 = (float)jarg4;
25954   arg5 = (float)jarg5;
25955   arg6 = (float)jarg6;
25956   {
25957     try {
25958       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25959     } catch (std::out_of_range& e) {
25960       {
25961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25962       };
25963     } catch (std::exception& e) {
25964       {
25965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25966       };
25967     } catch (...) {
25968       {
25969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25970       };
25971     }
25972   }
25973   jresult = (void *)result;
25974   return jresult;
25975 }
25976
25977
25978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25979   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25980
25981   arg1 = (Dali::TouchPoint *)jarg1;
25982   {
25983     try {
25984       delete arg1;
25985     } catch (std::out_of_range& e) {
25986       {
25987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25988       };
25989     } catch (std::exception& e) {
25990       {
25991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25992       };
25993     } catch (...) {
25994       {
25995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25996       };
25997     }
25998   }
25999 }
26000
26001
26002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26003   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26004   int arg2 ;
26005
26006   arg1 = (Dali::TouchPoint *)jarg1;
26007   arg2 = (int)jarg2;
26008   if (arg1) (arg1)->deviceId = arg2;
26009 }
26010
26011
26012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26013   int jresult ;
26014   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26015   int result;
26016
26017   arg1 = (Dali::TouchPoint *)jarg1;
26018   result = (int) ((arg1)->deviceId);
26019   jresult = result;
26020   return jresult;
26021 }
26022
26023
26024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26025   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26026   Dali::TouchPoint::State arg2 ;
26027
26028   arg1 = (Dali::TouchPoint *)jarg1;
26029   arg2 = (Dali::TouchPoint::State)jarg2;
26030   if (arg1) (arg1)->state = arg2;
26031 }
26032
26033
26034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26035   int jresult ;
26036   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26037   Dali::TouchPoint::State result;
26038
26039   arg1 = (Dali::TouchPoint *)jarg1;
26040   result = (Dali::TouchPoint::State) ((arg1)->state);
26041   jresult = (int)result;
26042   return jresult;
26043 }
26044
26045
26046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26047   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26048   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26049
26050   arg1 = (Dali::TouchPoint *)jarg1;
26051   arg2 = (Dali::Actor *)jarg2;
26052   if (arg1) (arg1)->hitActor = *arg2;
26053 }
26054
26055
26056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26057   void * jresult ;
26058   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26059   Dali::Actor *result = 0 ;
26060
26061   arg1 = (Dali::TouchPoint *)jarg1;
26062   result = (Dali::Actor *)& ((arg1)->hitActor);
26063   jresult = (void *)result;
26064   return jresult;
26065 }
26066
26067
26068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26069   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26070   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26071
26072   arg1 = (Dali::TouchPoint *)jarg1;
26073   arg2 = (Dali::Vector2 *)jarg2;
26074   if (arg1) (arg1)->local = *arg2;
26075 }
26076
26077
26078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26079   void * jresult ;
26080   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26081   Dali::Vector2 *result = 0 ;
26082
26083   arg1 = (Dali::TouchPoint *)jarg1;
26084   result = (Dali::Vector2 *)& ((arg1)->local);
26085   jresult = (void *)result;
26086   return jresult;
26087 }
26088
26089
26090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26091   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26092   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26093
26094   arg1 = (Dali::TouchPoint *)jarg1;
26095   arg2 = (Dali::Vector2 *)jarg2;
26096   if (arg1) (arg1)->screen = *arg2;
26097 }
26098
26099
26100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26101   void * jresult ;
26102   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26103   Dali::Vector2 *result = 0 ;
26104
26105   arg1 = (Dali::TouchPoint *)jarg1;
26106   result = (Dali::Vector2 *)& ((arg1)->screen);
26107   jresult = (void *)result;
26108   return jresult;
26109 }
26110
26111
26112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26113   void * jresult ;
26114   Dali::TouchData *result = 0 ;
26115
26116   {
26117     try {
26118       result = (Dali::TouchData *)new Dali::TouchData();
26119     } catch (std::out_of_range& e) {
26120       {
26121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26122       };
26123     } catch (std::exception& e) {
26124       {
26125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26126       };
26127     } catch (...) {
26128       {
26129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26130       };
26131     }
26132   }
26133   jresult = (void *)result;
26134   return jresult;
26135 }
26136
26137
26138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26139   void * jresult ;
26140   Dali::TouchData *arg1 = 0 ;
26141   Dali::TouchData *result = 0 ;
26142
26143   arg1 = (Dali::TouchData *)jarg1;
26144   if (!arg1) {
26145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26146     return 0;
26147   }
26148   {
26149     try {
26150       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26151     } catch (std::out_of_range& e) {
26152       {
26153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26154       };
26155     } catch (std::exception& e) {
26156       {
26157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26158       };
26159     } catch (...) {
26160       {
26161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26162       };
26163     }
26164   }
26165   jresult = (void *)result;
26166   return jresult;
26167 }
26168
26169
26170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26171   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26172
26173   arg1 = (Dali::TouchData *)jarg1;
26174   {
26175     try {
26176       delete arg1;
26177     } catch (std::out_of_range& e) {
26178       {
26179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26180       };
26181     } catch (std::exception& e) {
26182       {
26183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26184       };
26185     } catch (...) {
26186       {
26187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26188       };
26189     }
26190   }
26191 }
26192
26193
26194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26195   void * jresult ;
26196   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26197   Dali::TouchData *arg2 = 0 ;
26198   Dali::TouchData *result = 0 ;
26199
26200   arg1 = (Dali::TouchData *)jarg1;
26201   arg2 = (Dali::TouchData *)jarg2;
26202   if (!arg2) {
26203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26204     return 0;
26205   }
26206   {
26207     try {
26208       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26209     } catch (std::out_of_range& e) {
26210       {
26211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26212       };
26213     } catch (std::exception& e) {
26214       {
26215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26216       };
26217     } catch (...) {
26218       {
26219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26220       };
26221     }
26222   }
26223   jresult = (void *)result;
26224   return jresult;
26225 }
26226
26227
26228 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26229   unsigned long jresult ;
26230   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26231   unsigned long result;
26232
26233   arg1 = (Dali::TouchData *)jarg1;
26234   {
26235     try {
26236       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26237     } catch (std::out_of_range& e) {
26238       {
26239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26240       };
26241     } catch (std::exception& e) {
26242       {
26243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26244       };
26245     } catch (...) {
26246       {
26247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26248       };
26249     }
26250   }
26251   jresult = (unsigned long)result;
26252   return jresult;
26253 }
26254
26255
26256 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26257   unsigned long jresult ;
26258   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26259   std::size_t result;
26260
26261   arg1 = (Dali::TouchData *)jarg1;
26262   {
26263     try {
26264       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26265     } catch (std::out_of_range& e) {
26266       {
26267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26268       };
26269     } catch (std::exception& e) {
26270       {
26271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26272       };
26273     } catch (...) {
26274       {
26275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26276       };
26277     }
26278   }
26279   jresult = (unsigned long)result;
26280   return jresult;
26281 }
26282
26283
26284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26285   int jresult ;
26286   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26287   std::size_t arg2 ;
26288   int32_t result;
26289
26290   arg1 = (Dali::TouchData *)jarg1;
26291   arg2 = (std::size_t)jarg2;
26292   {
26293     try {
26294       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26295     } catch (std::out_of_range& e) {
26296       {
26297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26298       };
26299     } catch (std::exception& e) {
26300       {
26301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26302       };
26303     } catch (...) {
26304       {
26305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26306       };
26307     }
26308   }
26309   jresult = result;
26310   return jresult;
26311 }
26312
26313
26314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26315   int jresult ;
26316   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26317   std::size_t arg2 ;
26318   Dali::PointState::Type result;
26319
26320   arg1 = (Dali::TouchData *)jarg1;
26321   arg2 = (std::size_t)jarg2;
26322   {
26323     try {
26324       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26325     } catch (std::out_of_range& e) {
26326       {
26327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26328       };
26329     } catch (std::exception& e) {
26330       {
26331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26332       };
26333     } catch (...) {
26334       {
26335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26336       };
26337     }
26338   }
26339   jresult = (int)result;
26340   return jresult;
26341 }
26342
26343
26344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26345   void * jresult ;
26346   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26347   std::size_t arg2 ;
26348   Dali::Actor result;
26349
26350   arg1 = (Dali::TouchData *)jarg1;
26351   arg2 = (std::size_t)jarg2;
26352   {
26353     try {
26354       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26355     } catch (std::out_of_range& e) {
26356       {
26357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26358       };
26359     } catch (std::exception& e) {
26360       {
26361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26362       };
26363     } catch (...) {
26364       {
26365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26366       };
26367     }
26368   }
26369   jresult = new Dali::Actor((const Dali::Actor &)result);
26370   return jresult;
26371 }
26372
26373
26374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26375   void * jresult ;
26376   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26377   std::size_t arg2 ;
26378   Dali::Vector2 *result = 0 ;
26379
26380   arg1 = (Dali::TouchData *)jarg1;
26381   arg2 = (std::size_t)jarg2;
26382   {
26383     try {
26384       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26385     } catch (std::out_of_range& e) {
26386       {
26387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26388       };
26389     } catch (std::exception& e) {
26390       {
26391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26392       };
26393     } catch (...) {
26394       {
26395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26396       };
26397     }
26398   }
26399   jresult = (void *)result;
26400   return jresult;
26401 }
26402
26403
26404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26405   void * jresult ;
26406   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26407   std::size_t arg2 ;
26408   Dali::Vector2 *result = 0 ;
26409
26410   arg1 = (Dali::TouchData *)jarg1;
26411   arg2 = (std::size_t)jarg2;
26412   {
26413     try {
26414       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26415     } catch (std::out_of_range& e) {
26416       {
26417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26418       };
26419     } catch (std::exception& e) {
26420       {
26421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26422       };
26423     } catch (...) {
26424       {
26425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26426       };
26427     }
26428   }
26429   jresult = (void *)result;
26430   return jresult;
26431 }
26432
26433
26434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26435   float jresult ;
26436   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26437   std::size_t arg2 ;
26438   float result;
26439
26440   arg1 = (Dali::TouchData *)jarg1;
26441   arg2 = (std::size_t)jarg2;
26442   {
26443     try {
26444       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26445     } catch (std::out_of_range& e) {
26446       {
26447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26448       };
26449     } catch (std::exception& e) {
26450       {
26451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26452       };
26453     } catch (...) {
26454       {
26455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26456       };
26457     }
26458   }
26459   jresult = result;
26460   return jresult;
26461 }
26462
26463
26464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26465   void * jresult ;
26466   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26467   std::size_t arg2 ;
26468   Dali::Vector2 *result = 0 ;
26469
26470   arg1 = (Dali::TouchData *)jarg1;
26471   arg2 = (std::size_t)jarg2;
26472   {
26473     try {
26474       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26475     } catch (std::out_of_range& e) {
26476       {
26477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26478       };
26479     } catch (std::exception& e) {
26480       {
26481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26482       };
26483     } catch (...) {
26484       {
26485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26486       };
26487     }
26488   }
26489   jresult = (void *)result;
26490   return jresult;
26491 }
26492
26493
26494 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26495   float jresult ;
26496   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26497   std::size_t arg2 ;
26498   float result;
26499
26500   arg1 = (Dali::TouchData *)jarg1;
26501   arg2 = (std::size_t)jarg2;
26502   {
26503     try {
26504       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26505     } catch (std::out_of_range& e) {
26506       {
26507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26508       };
26509     } catch (std::exception& e) {
26510       {
26511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26512       };
26513     } catch (...) {
26514       {
26515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26516       };
26517     }
26518   }
26519   jresult = result;
26520   return jresult;
26521 }
26522
26523
26524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26525   void * jresult ;
26526   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26527   std::size_t arg2 ;
26528   Dali::Degree result;
26529
26530   arg1 = (Dali::TouchData *)jarg1;
26531   arg2 = (std::size_t)jarg2;
26532   {
26533     try {
26534       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26535     } catch (std::out_of_range& e) {
26536       {
26537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26538       };
26539     } catch (std::exception& e) {
26540       {
26541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26542       };
26543     } catch (...) {
26544       {
26545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26546       };
26547     }
26548   }
26549   jresult = new Dali::Degree((const Dali::Degree &)result);
26550   return jresult;
26551 }
26552
26553
26554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26555   void * jresult ;
26556   Dali::GestureDetector *result = 0 ;
26557
26558   {
26559     try {
26560       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26561     } catch (std::out_of_range& e) {
26562       {
26563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26564       };
26565     } catch (std::exception& e) {
26566       {
26567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26568       };
26569     } catch (...) {
26570       {
26571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26572       };
26573     }
26574   }
26575   jresult = (void *)result;
26576   return jresult;
26577 }
26578
26579
26580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26581   void * jresult ;
26582   Dali::BaseHandle arg1 ;
26583   Dali::BaseHandle *argp1 ;
26584   Dali::GestureDetector result;
26585
26586   argp1 = (Dali::BaseHandle *)jarg1;
26587   if (!argp1) {
26588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26589     return 0;
26590   }
26591   arg1 = *argp1;
26592   {
26593     try {
26594       result = Dali::GestureDetector::DownCast(arg1);
26595     } catch (std::out_of_range& e) {
26596       {
26597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26598       };
26599     } catch (std::exception& e) {
26600       {
26601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26602       };
26603     } catch (...) {
26604       {
26605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26606       };
26607     }
26608   }
26609   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26610   return jresult;
26611 }
26612
26613
26614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26615   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26616
26617   arg1 = (Dali::GestureDetector *)jarg1;
26618   {
26619     try {
26620       delete arg1;
26621     } catch (std::out_of_range& e) {
26622       {
26623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26624       };
26625     } catch (std::exception& e) {
26626       {
26627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26628       };
26629     } catch (...) {
26630       {
26631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26632       };
26633     }
26634   }
26635 }
26636
26637
26638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26639   void * jresult ;
26640   Dali::GestureDetector *arg1 = 0 ;
26641   Dali::GestureDetector *result = 0 ;
26642
26643   arg1 = (Dali::GestureDetector *)jarg1;
26644   if (!arg1) {
26645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26646     return 0;
26647   }
26648   {
26649     try {
26650       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26651     } catch (std::out_of_range& e) {
26652       {
26653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26654       };
26655     } catch (std::exception& e) {
26656       {
26657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26658       };
26659     } catch (...) {
26660       {
26661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26662       };
26663     }
26664   }
26665   jresult = (void *)result;
26666   return jresult;
26667 }
26668
26669
26670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26671   void * jresult ;
26672   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26673   Dali::GestureDetector *arg2 = 0 ;
26674   Dali::GestureDetector *result = 0 ;
26675
26676   arg1 = (Dali::GestureDetector *)jarg1;
26677   arg2 = (Dali::GestureDetector *)jarg2;
26678   if (!arg2) {
26679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26680     return 0;
26681   }
26682   {
26683     try {
26684       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26685     } catch (std::out_of_range& e) {
26686       {
26687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26688       };
26689     } catch (std::exception& e) {
26690       {
26691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26692       };
26693     } catch (...) {
26694       {
26695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26696       };
26697     }
26698   }
26699   jresult = (void *)result;
26700   return jresult;
26701 }
26702
26703
26704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26705   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26706   Dali::Actor arg2 ;
26707   Dali::Actor *argp2 ;
26708
26709   arg1 = (Dali::GestureDetector *)jarg1;
26710   argp2 = (Dali::Actor *)jarg2;
26711   if (!argp2) {
26712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26713     return ;
26714   }
26715   arg2 = *argp2;
26716   {
26717     try {
26718       (arg1)->Attach(arg2);
26719     } catch (std::out_of_range& e) {
26720       {
26721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26722       };
26723     } catch (std::exception& e) {
26724       {
26725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26726       };
26727     } catch (...) {
26728       {
26729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26730       };
26731     }
26732   }
26733 }
26734
26735
26736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26737   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26738   Dali::Actor arg2 ;
26739   Dali::Actor *argp2 ;
26740
26741   arg1 = (Dali::GestureDetector *)jarg1;
26742   argp2 = (Dali::Actor *)jarg2;
26743   if (!argp2) {
26744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26745     return ;
26746   }
26747   arg2 = *argp2;
26748   {
26749     try {
26750       (arg1)->Detach(arg2);
26751     } catch (std::out_of_range& e) {
26752       {
26753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26754       };
26755     } catch (std::exception& e) {
26756       {
26757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26758       };
26759     } catch (...) {
26760       {
26761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26762       };
26763     }
26764   }
26765 }
26766
26767
26768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26769   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26770
26771   arg1 = (Dali::GestureDetector *)jarg1;
26772   {
26773     try {
26774       (arg1)->DetachAll();
26775     } catch (std::out_of_range& e) {
26776       {
26777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26778       };
26779     } catch (std::exception& e) {
26780       {
26781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26782       };
26783     } catch (...) {
26784       {
26785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26786       };
26787     }
26788   }
26789 }
26790
26791
26792 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26793   unsigned long jresult ;
26794   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26795   size_t result;
26796
26797   arg1 = (Dali::GestureDetector *)jarg1;
26798   {
26799     try {
26800       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26801     } catch (std::out_of_range& e) {
26802       {
26803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26804       };
26805     } catch (std::exception& e) {
26806       {
26807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26808       };
26809     } catch (...) {
26810       {
26811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26812       };
26813     }
26814   }
26815   jresult = (unsigned long)result;
26816   return jresult;
26817 }
26818
26819
26820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26821   void * jresult ;
26822   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26823   size_t arg2 ;
26824   Dali::Actor result;
26825
26826   arg1 = (Dali::GestureDetector *)jarg1;
26827   arg2 = (size_t)jarg2;
26828   {
26829     try {
26830       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26831     } catch (std::out_of_range& e) {
26832       {
26833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26834       };
26835     } catch (std::exception& e) {
26836       {
26837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26838       };
26839     } catch (...) {
26840       {
26841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26842       };
26843     }
26844   }
26845   jresult = new Dali::Actor((const Dali::Actor &)result);
26846   return jresult;
26847 }
26848
26849
26850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26851   void * jresult ;
26852   Dali::Gesture *arg1 = 0 ;
26853   Dali::Gesture *result = 0 ;
26854
26855   arg1 = (Dali::Gesture *)jarg1;
26856   if (!arg1) {
26857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26858     return 0;
26859   }
26860   {
26861     try {
26862       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26863     } catch (std::out_of_range& e) {
26864       {
26865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26866       };
26867     } catch (std::exception& e) {
26868       {
26869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26870       };
26871     } catch (...) {
26872       {
26873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26874       };
26875     }
26876   }
26877   jresult = (void *)result;
26878   return jresult;
26879 }
26880
26881
26882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26883   void * jresult ;
26884   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26885   Dali::Gesture *arg2 = 0 ;
26886   Dali::Gesture *result = 0 ;
26887
26888   arg1 = (Dali::Gesture *)jarg1;
26889   arg2 = (Dali::Gesture *)jarg2;
26890   if (!arg2) {
26891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26892     return 0;
26893   }
26894   {
26895     try {
26896       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26897     } catch (std::out_of_range& e) {
26898       {
26899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26900       };
26901     } catch (std::exception& e) {
26902       {
26903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26904       };
26905     } catch (...) {
26906       {
26907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26908       };
26909     }
26910   }
26911   jresult = (void *)result;
26912   return jresult;
26913 }
26914
26915
26916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26917   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26918
26919   arg1 = (Dali::Gesture *)jarg1;
26920   {
26921     try {
26922       delete arg1;
26923     } catch (std::out_of_range& e) {
26924       {
26925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26926       };
26927     } catch (std::exception& e) {
26928       {
26929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26930       };
26931     } catch (...) {
26932       {
26933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26934       };
26935     }
26936   }
26937 }
26938
26939
26940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26941   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26942   Dali::Gesture::Type arg2 ;
26943
26944   arg1 = (Dali::Gesture *)jarg1;
26945   arg2 = (Dali::Gesture::Type)jarg2;
26946   if (arg1) (arg1)->type = arg2;
26947 }
26948
26949
26950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26951   int jresult ;
26952   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26953   Dali::Gesture::Type result;
26954
26955   arg1 = (Dali::Gesture *)jarg1;
26956   result = (Dali::Gesture::Type) ((arg1)->type);
26957   jresult = (int)result;
26958   return jresult;
26959 }
26960
26961
26962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26963   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26964   Dali::Gesture::State arg2 ;
26965
26966   arg1 = (Dali::Gesture *)jarg1;
26967   arg2 = (Dali::Gesture::State)jarg2;
26968   if (arg1) (arg1)->state = arg2;
26969 }
26970
26971
26972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26973   int jresult ;
26974   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26975   Dali::Gesture::State result;
26976
26977   arg1 = (Dali::Gesture *)jarg1;
26978   result = (Dali::Gesture::State) ((arg1)->state);
26979   jresult = (int)result;
26980   return jresult;
26981 }
26982
26983
26984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
26985   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26986   unsigned int arg2 ;
26987
26988   arg1 = (Dali::Gesture *)jarg1;
26989   arg2 = (unsigned int)jarg2;
26990   if (arg1) (arg1)->time = arg2;
26991 }
26992
26993
26994 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
26995   unsigned int jresult ;
26996   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26997   unsigned int result;
26998
26999   arg1 = (Dali::Gesture *)jarg1;
27000   result = (unsigned int) ((arg1)->time);
27001   jresult = result;
27002   return jresult;
27003 }
27004
27005
27006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27007   void * jresult ;
27008   Dali::HoverEvent *result = 0 ;
27009
27010   {
27011     try {
27012       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27013     } catch (std::out_of_range& e) {
27014       {
27015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27016       };
27017     } catch (std::exception& e) {
27018       {
27019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27020       };
27021     } catch (...) {
27022       {
27023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27024       };
27025     }
27026   }
27027   jresult = (void *)result;
27028   return jresult;
27029 }
27030
27031
27032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27033   void * jresult ;
27034   unsigned long arg1 ;
27035   Dali::HoverEvent *result = 0 ;
27036
27037   arg1 = (unsigned long)jarg1;
27038   {
27039     try {
27040       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27041     } catch (std::out_of_range& e) {
27042       {
27043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27044       };
27045     } catch (std::exception& e) {
27046       {
27047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27048       };
27049     } catch (...) {
27050       {
27051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27052       };
27053     }
27054   }
27055   jresult = (void *)result;
27056   return jresult;
27057 }
27058
27059
27060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27061   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27062
27063   arg1 = (Dali::HoverEvent *)jarg1;
27064   {
27065     try {
27066       delete arg1;
27067     } catch (std::out_of_range& e) {
27068       {
27069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27070       };
27071     } catch (std::exception& e) {
27072       {
27073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27074       };
27075     } catch (...) {
27076       {
27077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27078       };
27079     }
27080   }
27081 }
27082
27083
27084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27085   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27086   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27087
27088   arg1 = (Dali::HoverEvent *)jarg1;
27089   arg2 = (Dali::TouchPointContainer *)jarg2;
27090   if (arg1) (arg1)->points = *arg2;
27091 }
27092
27093
27094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27095   void * jresult ;
27096   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27097   Dali::TouchPointContainer *result = 0 ;
27098
27099   arg1 = (Dali::HoverEvent *)jarg1;
27100   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27101   jresult = (void *)result;
27102   return jresult;
27103 }
27104
27105
27106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27107   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27108   unsigned long arg2 ;
27109
27110   arg1 = (Dali::HoverEvent *)jarg1;
27111   arg2 = (unsigned long)jarg2;
27112   if (arg1) (arg1)->time = arg2;
27113 }
27114
27115
27116 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27117   unsigned long jresult ;
27118   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27119   unsigned long result;
27120
27121   arg1 = (Dali::HoverEvent *)jarg1;
27122   result = (unsigned long) ((arg1)->time);
27123   jresult = (unsigned long)result;
27124   return jresult;
27125 }
27126
27127
27128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27129   unsigned int jresult ;
27130   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27131   unsigned int result;
27132
27133   arg1 = (Dali::HoverEvent *)jarg1;
27134   {
27135     try {
27136       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27137     } catch (std::out_of_range& e) {
27138       {
27139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27140       };
27141     } catch (std::exception& e) {
27142       {
27143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27144       };
27145     } catch (...) {
27146       {
27147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27148       };
27149     }
27150   }
27151   jresult = result;
27152   return jresult;
27153 }
27154
27155
27156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27157   void * jresult ;
27158   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27159   unsigned int arg2 ;
27160   Dali::TouchPoint *result = 0 ;
27161
27162   arg1 = (Dali::HoverEvent *)jarg1;
27163   arg2 = (unsigned int)jarg2;
27164   {
27165     try {
27166       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27167     } catch (std::out_of_range& e) {
27168       {
27169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27170       };
27171     } catch (std::exception& e) {
27172       {
27173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27174       };
27175     } catch (...) {
27176       {
27177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27178       };
27179     }
27180   }
27181   jresult = (void *)result;
27182   return jresult;
27183 }
27184
27185
27186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27187   void * jresult ;
27188   Dali::KeyEvent *result = 0 ;
27189
27190   {
27191     try {
27192       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27193     } catch (std::out_of_range& e) {
27194       {
27195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27196       };
27197     } catch (std::exception& e) {
27198       {
27199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27200       };
27201     } catch (...) {
27202       {
27203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27204       };
27205     }
27206   }
27207   jresult = (void *)result;
27208   return jresult;
27209 }
27210
27211
27212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27213   void * jresult ;
27214   std::string *arg1 = 0 ;
27215   std::string *arg2 = 0 ;
27216   int arg3 ;
27217   int arg4 ;
27218   unsigned long arg5 ;
27219   Dali::KeyEvent::State *arg6 = 0 ;
27220   Dali::KeyEvent::State temp6 ;
27221   Dali::KeyEvent *result = 0 ;
27222
27223   if (!jarg1) {
27224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27225     return 0;
27226   }
27227   std::string arg1_str(jarg1);
27228   arg1 = &arg1_str;
27229   if (!jarg2) {
27230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27231     return 0;
27232   }
27233   std::string arg2_str(jarg2);
27234   arg2 = &arg2_str;
27235   arg3 = (int)jarg3;
27236   arg4 = (int)jarg4;
27237   arg5 = (unsigned long)jarg5;
27238   temp6 = (Dali::KeyEvent::State)jarg6;
27239   arg6 = &temp6;
27240   {
27241     try {
27242       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27243     } catch (std::out_of_range& e) {
27244       {
27245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27246       };
27247     } catch (std::exception& e) {
27248       {
27249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27250       };
27251     } catch (...) {
27252       {
27253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27254       };
27255     }
27256   }
27257   jresult = (void *)result;
27258
27259   //argout typemap for const std::string&
27260
27261
27262   //argout typemap for const std::string&
27263
27264   return jresult;
27265 }
27266
27267
27268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27269   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27270
27271   arg1 = (Dali::KeyEvent *)jarg1;
27272   {
27273     try {
27274       delete arg1;
27275     } catch (std::out_of_range& e) {
27276       {
27277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27278       };
27279     } catch (std::exception& e) {
27280       {
27281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27282       };
27283     } catch (...) {
27284       {
27285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27286       };
27287     }
27288   }
27289 }
27290
27291
27292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27293   unsigned int jresult ;
27294   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27295   bool result;
27296
27297   arg1 = (Dali::KeyEvent *)jarg1;
27298   {
27299     try {
27300       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27301     } catch (std::out_of_range& e) {
27302       {
27303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27304       };
27305     } catch (std::exception& e) {
27306       {
27307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27308       };
27309     } catch (...) {
27310       {
27311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27312       };
27313     }
27314   }
27315   jresult = result;
27316   return jresult;
27317 }
27318
27319
27320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27321   unsigned int jresult ;
27322   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27323   bool result;
27324
27325   arg1 = (Dali::KeyEvent *)jarg1;
27326   {
27327     try {
27328       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27329     } catch (std::out_of_range& e) {
27330       {
27331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27332       };
27333     } catch (std::exception& e) {
27334       {
27335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27336       };
27337     } catch (...) {
27338       {
27339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27340       };
27341     }
27342   }
27343   jresult = result;
27344   return jresult;
27345 }
27346
27347
27348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27349   unsigned int jresult ;
27350   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27351   bool result;
27352
27353   arg1 = (Dali::KeyEvent *)jarg1;
27354   {
27355     try {
27356       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27357     } catch (std::out_of_range& e) {
27358       {
27359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27360       };
27361     } catch (std::exception& e) {
27362       {
27363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27364       };
27365     } catch (...) {
27366       {
27367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27368       };
27369     }
27370   }
27371   jresult = result;
27372   return jresult;
27373 }
27374
27375
27376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27377   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27378   std::string *arg2 = 0 ;
27379
27380   arg1 = (Dali::KeyEvent *)jarg1;
27381   if (!jarg2) {
27382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27383     return ;
27384   }
27385   std::string arg2_str(jarg2);
27386   arg2 = &arg2_str;
27387   if (arg1) (arg1)->keyPressedName = *arg2;
27388
27389   //argout typemap for const std::string&
27390
27391 }
27392
27393
27394 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27395   char * jresult ;
27396   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27397   std::string *result = 0 ;
27398
27399   arg1 = (Dali::KeyEvent *)jarg1;
27400   result = (std::string *) & ((arg1)->keyPressedName);
27401   jresult = SWIG_csharp_string_callback(result->c_str());
27402   return jresult;
27403 }
27404
27405
27406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27407   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27408   std::string *arg2 = 0 ;
27409
27410   arg1 = (Dali::KeyEvent *)jarg1;
27411   if (!jarg2) {
27412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27413     return ;
27414   }
27415   std::string arg2_str(jarg2);
27416   arg2 = &arg2_str;
27417   if (arg1) (arg1)->keyPressed = *arg2;
27418
27419   //argout typemap for const std::string&
27420
27421 }
27422
27423
27424 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27425   char * jresult ;
27426   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27427   std::string *result = 0 ;
27428
27429   arg1 = (Dali::KeyEvent *)jarg1;
27430   result = (std::string *) & ((arg1)->keyPressed);
27431   jresult = SWIG_csharp_string_callback(result->c_str());
27432   return jresult;
27433 }
27434
27435
27436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27437   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27438   int arg2 ;
27439
27440   arg1 = (Dali::KeyEvent *)jarg1;
27441   arg2 = (int)jarg2;
27442   if (arg1) (arg1)->keyCode = arg2;
27443 }
27444
27445
27446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27447   int jresult ;
27448   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27449   int result;
27450
27451   arg1 = (Dali::KeyEvent *)jarg1;
27452   result = (int) ((arg1)->keyCode);
27453   jresult = result;
27454   return jresult;
27455 }
27456
27457
27458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27459   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27460   int arg2 ;
27461
27462   arg1 = (Dali::KeyEvent *)jarg1;
27463   arg2 = (int)jarg2;
27464   if (arg1) (arg1)->keyModifier = arg2;
27465 }
27466
27467
27468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27469   int jresult ;
27470   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27471   int result;
27472
27473   arg1 = (Dali::KeyEvent *)jarg1;
27474   result = (int) ((arg1)->keyModifier);
27475   jresult = result;
27476   return jresult;
27477 }
27478
27479
27480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27481   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27482   unsigned long arg2 ;
27483
27484   arg1 = (Dali::KeyEvent *)jarg1;
27485   arg2 = (unsigned long)jarg2;
27486   if (arg1) (arg1)->time = arg2;
27487 }
27488
27489
27490 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27491   unsigned long jresult ;
27492   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27493   unsigned long result;
27494
27495   arg1 = (Dali::KeyEvent *)jarg1;
27496   result = (unsigned long) ((arg1)->time);
27497   jresult = (unsigned long)result;
27498   return jresult;
27499 }
27500
27501
27502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27503   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27504   Dali::KeyEvent::State arg2 ;
27505
27506   arg1 = (Dali::KeyEvent *)jarg1;
27507   arg2 = (Dali::KeyEvent::State)jarg2;
27508   if (arg1) (arg1)->state = arg2;
27509 }
27510
27511
27512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27513   int jresult ;
27514   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27515   Dali::KeyEvent::State result;
27516
27517   arg1 = (Dali::KeyEvent *)jarg1;
27518   result = (Dali::KeyEvent::State) ((arg1)->state);
27519   jresult = (int)result;
27520   return jresult;
27521 }
27522
27523
27524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27525   void * jresult ;
27526   Dali::LongPressGestureDetector *result = 0 ;
27527
27528   {
27529     try {
27530       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27531     } catch (std::out_of_range& e) {
27532       {
27533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27534       };
27535     } catch (std::exception& e) {
27536       {
27537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27538       };
27539     } catch (...) {
27540       {
27541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27542       };
27543     }
27544   }
27545   jresult = (void *)result;
27546   return jresult;
27547 }
27548
27549
27550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27551   void * jresult ;
27552   Dali::LongPressGestureDetector result;
27553
27554   {
27555     try {
27556       result = Dali::LongPressGestureDetector::New();
27557     } catch (std::out_of_range& e) {
27558       {
27559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27560       };
27561     } catch (std::exception& e) {
27562       {
27563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27564       };
27565     } catch (...) {
27566       {
27567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27568       };
27569     }
27570   }
27571   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27572   return jresult;
27573 }
27574
27575
27576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27577   void * jresult ;
27578   unsigned int arg1 ;
27579   Dali::LongPressGestureDetector result;
27580
27581   arg1 = (unsigned int)jarg1;
27582   {
27583     try {
27584       result = Dali::LongPressGestureDetector::New(arg1);
27585     } catch (std::out_of_range& e) {
27586       {
27587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27588       };
27589     } catch (std::exception& e) {
27590       {
27591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27592       };
27593     } catch (...) {
27594       {
27595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27596       };
27597     }
27598   }
27599   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27600   return jresult;
27601 }
27602
27603
27604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27605   void * jresult ;
27606   unsigned int arg1 ;
27607   unsigned int arg2 ;
27608   Dali::LongPressGestureDetector result;
27609
27610   arg1 = (unsigned int)jarg1;
27611   arg2 = (unsigned int)jarg2;
27612   {
27613     try {
27614       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27615     } catch (std::out_of_range& e) {
27616       {
27617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27618       };
27619     } catch (std::exception& e) {
27620       {
27621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27622       };
27623     } catch (...) {
27624       {
27625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27626       };
27627     }
27628   }
27629   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27630   return jresult;
27631 }
27632
27633
27634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27635   void * jresult ;
27636   Dali::BaseHandle arg1 ;
27637   Dali::BaseHandle *argp1 ;
27638   Dali::LongPressGestureDetector result;
27639
27640   argp1 = (Dali::BaseHandle *)jarg1;
27641   if (!argp1) {
27642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27643     return 0;
27644   }
27645   arg1 = *argp1;
27646   {
27647     try {
27648       result = Dali::LongPressGestureDetector::DownCast(arg1);
27649     } catch (std::out_of_range& e) {
27650       {
27651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27652       };
27653     } catch (std::exception& e) {
27654       {
27655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27656       };
27657     } catch (...) {
27658       {
27659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27660       };
27661     }
27662   }
27663   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27664   return jresult;
27665 }
27666
27667
27668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27669   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27670
27671   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27672   {
27673     try {
27674       delete arg1;
27675     } catch (std::out_of_range& e) {
27676       {
27677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27678       };
27679     } catch (std::exception& e) {
27680       {
27681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27682       };
27683     } catch (...) {
27684       {
27685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27686       };
27687     }
27688   }
27689 }
27690
27691
27692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27693   void * jresult ;
27694   Dali::LongPressGestureDetector *arg1 = 0 ;
27695   Dali::LongPressGestureDetector *result = 0 ;
27696
27697   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27698   if (!arg1) {
27699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27700     return 0;
27701   }
27702   {
27703     try {
27704       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27705     } catch (std::out_of_range& e) {
27706       {
27707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27708       };
27709     } catch (std::exception& e) {
27710       {
27711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27712       };
27713     } catch (...) {
27714       {
27715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27716       };
27717     }
27718   }
27719   jresult = (void *)result;
27720   return jresult;
27721 }
27722
27723
27724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27725   void * jresult ;
27726   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27727   Dali::LongPressGestureDetector *arg2 = 0 ;
27728   Dali::LongPressGestureDetector *result = 0 ;
27729
27730   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27731   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27732   if (!arg2) {
27733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27734     return 0;
27735   }
27736   {
27737     try {
27738       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27739     } catch (std::out_of_range& e) {
27740       {
27741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27742       };
27743     } catch (std::exception& e) {
27744       {
27745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27746       };
27747     } catch (...) {
27748       {
27749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27750       };
27751     }
27752   }
27753   jresult = (void *)result;
27754   return jresult;
27755 }
27756
27757
27758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27759   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27760   unsigned int arg2 ;
27761
27762   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27763   arg2 = (unsigned int)jarg2;
27764   {
27765     try {
27766       (arg1)->SetTouchesRequired(arg2);
27767     } catch (std::out_of_range& e) {
27768       {
27769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27770       };
27771     } catch (std::exception& e) {
27772       {
27773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27774       };
27775     } catch (...) {
27776       {
27777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27778       };
27779     }
27780   }
27781 }
27782
27783
27784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27785   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27786   unsigned int arg2 ;
27787   unsigned int arg3 ;
27788
27789   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27790   arg2 = (unsigned int)jarg2;
27791   arg3 = (unsigned int)jarg3;
27792   {
27793     try {
27794       (arg1)->SetTouchesRequired(arg2,arg3);
27795     } catch (std::out_of_range& e) {
27796       {
27797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27798       };
27799     } catch (std::exception& e) {
27800       {
27801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27802       };
27803     } catch (...) {
27804       {
27805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27806       };
27807     }
27808   }
27809 }
27810
27811
27812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27813   unsigned int jresult ;
27814   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27815   unsigned int result;
27816
27817   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27818   {
27819     try {
27820       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27821     } catch (std::out_of_range& e) {
27822       {
27823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27824       };
27825     } catch (std::exception& e) {
27826       {
27827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27828       };
27829     } catch (...) {
27830       {
27831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27832       };
27833     }
27834   }
27835   jresult = result;
27836   return jresult;
27837 }
27838
27839
27840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27841   unsigned int jresult ;
27842   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27843   unsigned int result;
27844
27845   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27846   {
27847     try {
27848       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27849     } catch (std::out_of_range& e) {
27850       {
27851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27852       };
27853     } catch (std::exception& e) {
27854       {
27855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27856       };
27857     } catch (...) {
27858       {
27859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27860       };
27861     }
27862   }
27863   jresult = result;
27864   return jresult;
27865 }
27866
27867
27868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27869   void * jresult ;
27870   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27871   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27872
27873   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27874   {
27875     try {
27876       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27877     } catch (std::out_of_range& e) {
27878       {
27879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27880       };
27881     } catch (std::exception& e) {
27882       {
27883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27884       };
27885     } catch (...) {
27886       {
27887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27888       };
27889     }
27890   }
27891   jresult = (void *)result;
27892   return jresult;
27893 }
27894
27895
27896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27897   void * jresult ;
27898   Dali::Gesture::State arg1 ;
27899   Dali::LongPressGesture *result = 0 ;
27900
27901   arg1 = (Dali::Gesture::State)jarg1;
27902   {
27903     try {
27904       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27905     } catch (std::out_of_range& e) {
27906       {
27907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27908       };
27909     } catch (std::exception& e) {
27910       {
27911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27912       };
27913     } catch (...) {
27914       {
27915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27916       };
27917     }
27918   }
27919   jresult = (void *)result;
27920   return jresult;
27921 }
27922
27923
27924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
27925   void * jresult ;
27926   Dali::LongPressGesture *arg1 = 0 ;
27927   Dali::LongPressGesture *result = 0 ;
27928
27929   arg1 = (Dali::LongPressGesture *)jarg1;
27930   if (!arg1) {
27931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27932     return 0;
27933   }
27934   {
27935     try {
27936       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
27937     } catch (std::out_of_range& e) {
27938       {
27939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27940       };
27941     } catch (std::exception& e) {
27942       {
27943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27944       };
27945     } catch (...) {
27946       {
27947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27948       };
27949     }
27950   }
27951   jresult = (void *)result;
27952   return jresult;
27953 }
27954
27955
27956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
27957   void * jresult ;
27958   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27959   Dali::LongPressGesture *arg2 = 0 ;
27960   Dali::LongPressGesture *result = 0 ;
27961
27962   arg1 = (Dali::LongPressGesture *)jarg1;
27963   arg2 = (Dali::LongPressGesture *)jarg2;
27964   if (!arg2) {
27965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
27966     return 0;
27967   }
27968   {
27969     try {
27970       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
27971     } catch (std::out_of_range& e) {
27972       {
27973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27974       };
27975     } catch (std::exception& e) {
27976       {
27977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27978       };
27979     } catch (...) {
27980       {
27981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27982       };
27983     }
27984   }
27985   jresult = (void *)result;
27986   return jresult;
27987 }
27988
27989
27990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
27991   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
27992
27993   arg1 = (Dali::LongPressGesture *)jarg1;
27994   {
27995     try {
27996       delete arg1;
27997     } catch (std::out_of_range& e) {
27998       {
27999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28000       };
28001     } catch (std::exception& e) {
28002       {
28003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28004       };
28005     } catch (...) {
28006       {
28007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28008       };
28009     }
28010   }
28011 }
28012
28013
28014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28015   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28016   unsigned int arg2 ;
28017
28018   arg1 = (Dali::LongPressGesture *)jarg1;
28019   arg2 = (unsigned int)jarg2;
28020   if (arg1) (arg1)->numberOfTouches = arg2;
28021 }
28022
28023
28024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28025   unsigned int jresult ;
28026   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28027   unsigned int result;
28028
28029   arg1 = (Dali::LongPressGesture *)jarg1;
28030   result = (unsigned int) ((arg1)->numberOfTouches);
28031   jresult = result;
28032   return jresult;
28033 }
28034
28035
28036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28037   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28038   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28039
28040   arg1 = (Dali::LongPressGesture *)jarg1;
28041   arg2 = (Dali::Vector2 *)jarg2;
28042   if (arg1) (arg1)->screenPoint = *arg2;
28043 }
28044
28045
28046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28047   void * jresult ;
28048   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28049   Dali::Vector2 *result = 0 ;
28050
28051   arg1 = (Dali::LongPressGesture *)jarg1;
28052   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28053   jresult = (void *)result;
28054   return jresult;
28055 }
28056
28057
28058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28059   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28060   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28061
28062   arg1 = (Dali::LongPressGesture *)jarg1;
28063   arg2 = (Dali::Vector2 *)jarg2;
28064   if (arg1) (arg1)->localPoint = *arg2;
28065 }
28066
28067
28068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28069   void * jresult ;
28070   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28071   Dali::Vector2 *result = 0 ;
28072
28073   arg1 = (Dali::LongPressGesture *)jarg1;
28074   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28075   jresult = (void *)result;
28076   return jresult;
28077 }
28078
28079
28080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28081   void * jresult ;
28082   Dali::WheelEvent *result = 0 ;
28083
28084   {
28085     try {
28086       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28087     } catch (std::out_of_range& e) {
28088       {
28089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28090       };
28091     } catch (std::exception& e) {
28092       {
28093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28094       };
28095     } catch (...) {
28096       {
28097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28098       };
28099     }
28100   }
28101   jresult = (void *)result;
28102   return jresult;
28103 }
28104
28105
28106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28107   void * jresult ;
28108   Dali::WheelEvent::Type arg1 ;
28109   int arg2 ;
28110   unsigned int arg3 ;
28111   Dali::Vector2 arg4 ;
28112   int arg5 ;
28113   unsigned int arg6 ;
28114   Dali::Vector2 *argp4 ;
28115   Dali::WheelEvent *result = 0 ;
28116
28117   arg1 = (Dali::WheelEvent::Type)jarg1;
28118   arg2 = (int)jarg2;
28119   arg3 = (unsigned int)jarg3;
28120   argp4 = (Dali::Vector2 *)jarg4;
28121   if (!argp4) {
28122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28123     return 0;
28124   }
28125   arg4 = *argp4;
28126   arg5 = (int)jarg5;
28127   arg6 = (unsigned int)jarg6;
28128   {
28129     try {
28130       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28131     } catch (std::out_of_range& e) {
28132       {
28133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28134       };
28135     } catch (std::exception& e) {
28136       {
28137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28138       };
28139     } catch (...) {
28140       {
28141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28142       };
28143     }
28144   }
28145   jresult = (void *)result;
28146   return jresult;
28147 }
28148
28149
28150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28151   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28152
28153   arg1 = (Dali::WheelEvent *)jarg1;
28154   {
28155     try {
28156       delete arg1;
28157     } catch (std::out_of_range& e) {
28158       {
28159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28160       };
28161     } catch (std::exception& e) {
28162       {
28163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28164       };
28165     } catch (...) {
28166       {
28167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28168       };
28169     }
28170   }
28171 }
28172
28173
28174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28175   unsigned int jresult ;
28176   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28177   bool result;
28178
28179   arg1 = (Dali::WheelEvent *)jarg1;
28180   {
28181     try {
28182       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28183     } catch (std::out_of_range& e) {
28184       {
28185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28186       };
28187     } catch (std::exception& e) {
28188       {
28189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28190       };
28191     } catch (...) {
28192       {
28193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28194       };
28195     }
28196   }
28197   jresult = result;
28198   return jresult;
28199 }
28200
28201
28202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28203   unsigned int jresult ;
28204   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28205   bool result;
28206
28207   arg1 = (Dali::WheelEvent *)jarg1;
28208   {
28209     try {
28210       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28211     } catch (std::out_of_range& e) {
28212       {
28213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28214       };
28215     } catch (std::exception& e) {
28216       {
28217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28218       };
28219     } catch (...) {
28220       {
28221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28222       };
28223     }
28224   }
28225   jresult = result;
28226   return jresult;
28227 }
28228
28229
28230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28231   unsigned int jresult ;
28232   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28233   bool result;
28234
28235   arg1 = (Dali::WheelEvent *)jarg1;
28236   {
28237     try {
28238       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28239     } catch (std::out_of_range& e) {
28240       {
28241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28242       };
28243     } catch (std::exception& e) {
28244       {
28245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28246       };
28247     } catch (...) {
28248       {
28249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28250       };
28251     }
28252   }
28253   jresult = result;
28254   return jresult;
28255 }
28256
28257
28258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28259   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28260   Dali::WheelEvent::Type arg2 ;
28261
28262   arg1 = (Dali::WheelEvent *)jarg1;
28263   arg2 = (Dali::WheelEvent::Type)jarg2;
28264   if (arg1) (arg1)->type = arg2;
28265 }
28266
28267
28268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28269   int jresult ;
28270   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28271   Dali::WheelEvent::Type result;
28272
28273   arg1 = (Dali::WheelEvent *)jarg1;
28274   result = (Dali::WheelEvent::Type) ((arg1)->type);
28275   jresult = (int)result;
28276   return jresult;
28277 }
28278
28279
28280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28281   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28282   int arg2 ;
28283
28284   arg1 = (Dali::WheelEvent *)jarg1;
28285   arg2 = (int)jarg2;
28286   if (arg1) (arg1)->direction = arg2;
28287 }
28288
28289
28290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28291   int jresult ;
28292   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28293   int result;
28294
28295   arg1 = (Dali::WheelEvent *)jarg1;
28296   result = (int) ((arg1)->direction);
28297   jresult = result;
28298   return jresult;
28299 }
28300
28301
28302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28303   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28304   unsigned int arg2 ;
28305
28306   arg1 = (Dali::WheelEvent *)jarg1;
28307   arg2 = (unsigned int)jarg2;
28308   if (arg1) (arg1)->modifiers = arg2;
28309 }
28310
28311
28312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28313   unsigned int jresult ;
28314   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28315   unsigned int result;
28316
28317   arg1 = (Dali::WheelEvent *)jarg1;
28318   result = (unsigned int) ((arg1)->modifiers);
28319   jresult = result;
28320   return jresult;
28321 }
28322
28323
28324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28325   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28326   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28327
28328   arg1 = (Dali::WheelEvent *)jarg1;
28329   arg2 = (Dali::Vector2 *)jarg2;
28330   if (arg1) (arg1)->point = *arg2;
28331 }
28332
28333
28334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28335   void * jresult ;
28336   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28337   Dali::Vector2 *result = 0 ;
28338
28339   arg1 = (Dali::WheelEvent *)jarg1;
28340   result = (Dali::Vector2 *)& ((arg1)->point);
28341   jresult = (void *)result;
28342   return jresult;
28343 }
28344
28345
28346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28347   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28348   int arg2 ;
28349
28350   arg1 = (Dali::WheelEvent *)jarg1;
28351   arg2 = (int)jarg2;
28352   if (arg1) (arg1)->z = arg2;
28353 }
28354
28355
28356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28357   int jresult ;
28358   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28359   int result;
28360
28361   arg1 = (Dali::WheelEvent *)jarg1;
28362   result = (int) ((arg1)->z);
28363   jresult = result;
28364   return jresult;
28365 }
28366
28367
28368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28369   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28370   unsigned int arg2 ;
28371
28372   arg1 = (Dali::WheelEvent *)jarg1;
28373   arg2 = (unsigned int)jarg2;
28374   if (arg1) (arg1)->timeStamp = arg2;
28375 }
28376
28377
28378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28379   unsigned int jresult ;
28380   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28381   unsigned int result;
28382
28383   arg1 = (Dali::WheelEvent *)jarg1;
28384   result = (unsigned int) ((arg1)->timeStamp);
28385   jresult = result;
28386   return jresult;
28387 }
28388
28389
28390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28391   int jresult ;
28392   int result;
28393
28394   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28395   jresult = (int)result;
28396   return jresult;
28397 }
28398
28399
28400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28401   int jresult ;
28402   int result;
28403
28404   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28405   jresult = (int)result;
28406   return jresult;
28407 }
28408
28409
28410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28411   int jresult ;
28412   int result;
28413
28414   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28415   jresult = (int)result;
28416   return jresult;
28417 }
28418
28419
28420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28421   int jresult ;
28422   int result;
28423
28424   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28425   jresult = (int)result;
28426   return jresult;
28427 }
28428
28429
28430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28431   int jresult ;
28432   int result;
28433
28434   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28435   jresult = (int)result;
28436   return jresult;
28437 }
28438
28439
28440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28441   int jresult ;
28442   int result;
28443
28444   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28445   jresult = (int)result;
28446   return jresult;
28447 }
28448
28449
28450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28451   int jresult ;
28452   int result;
28453
28454   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28455   jresult = (int)result;
28456   return jresult;
28457 }
28458
28459
28460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28461   int jresult ;
28462   int result;
28463
28464   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28465   jresult = (int)result;
28466   return jresult;
28467 }
28468
28469
28470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28471   int jresult ;
28472   int result;
28473
28474   result = (int)Dali::Actor::Property::SIZE;
28475   jresult = (int)result;
28476   return jresult;
28477 }
28478
28479
28480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28481   int jresult ;
28482   int result;
28483
28484   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28485   jresult = (int)result;
28486   return jresult;
28487 }
28488
28489
28490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28491   int jresult ;
28492   int result;
28493
28494   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28495   jresult = (int)result;
28496   return jresult;
28497 }
28498
28499
28500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28501   int jresult ;
28502   int result;
28503
28504   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28505   jresult = (int)result;
28506   return jresult;
28507 }
28508
28509
28510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28511   int jresult ;
28512   int result;
28513
28514   result = (int)Dali::Actor::Property::POSITION;
28515   jresult = (int)result;
28516   return jresult;
28517 }
28518
28519
28520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28521   int jresult ;
28522   int result;
28523
28524   result = (int)Dali::Actor::Property::POSITION_X;
28525   jresult = (int)result;
28526   return jresult;
28527 }
28528
28529
28530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28531   int jresult ;
28532   int result;
28533
28534   result = (int)Dali::Actor::Property::POSITION_Y;
28535   jresult = (int)result;
28536   return jresult;
28537 }
28538
28539
28540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28541   int jresult ;
28542   int result;
28543
28544   result = (int)Dali::Actor::Property::POSITION_Z;
28545   jresult = (int)result;
28546   return jresult;
28547 }
28548
28549
28550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28551   int jresult ;
28552   int result;
28553
28554   result = (int)Dali::Actor::Property::WORLD_POSITION;
28555   jresult = (int)result;
28556   return jresult;
28557 }
28558
28559
28560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28561   int jresult ;
28562   int result;
28563
28564   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28565   jresult = (int)result;
28566   return jresult;
28567 }
28568
28569
28570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28571   int jresult ;
28572   int result;
28573
28574   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28575   jresult = (int)result;
28576   return jresult;
28577 }
28578
28579
28580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28581   int jresult ;
28582   int result;
28583
28584   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28585   jresult = (int)result;
28586   return jresult;
28587 }
28588
28589
28590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28591   int jresult ;
28592   int result;
28593
28594   result = (int)Dali::Actor::Property::ORIENTATION;
28595   jresult = (int)result;
28596   return jresult;
28597 }
28598
28599
28600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28601   int jresult ;
28602   int result;
28603
28604   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28605   jresult = (int)result;
28606   return jresult;
28607 }
28608
28609
28610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28611   int jresult ;
28612   int result;
28613
28614   result = (int)Dali::Actor::Property::SCALE;
28615   jresult = (int)result;
28616   return jresult;
28617 }
28618
28619
28620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28621   int jresult ;
28622   int result;
28623
28624   result = (int)Dali::Actor::Property::SCALE_X;
28625   jresult = (int)result;
28626   return jresult;
28627 }
28628
28629
28630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28631   int jresult ;
28632   int result;
28633
28634   result = (int)Dali::Actor::Property::SCALE_Y;
28635   jresult = (int)result;
28636   return jresult;
28637 }
28638
28639
28640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28641   int jresult ;
28642   int result;
28643
28644   result = (int)Dali::Actor::Property::SCALE_Z;
28645   jresult = (int)result;
28646   return jresult;
28647 }
28648
28649
28650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28651   int jresult ;
28652   int result;
28653
28654   result = (int)Dali::Actor::Property::WORLD_SCALE;
28655   jresult = (int)result;
28656   return jresult;
28657 }
28658
28659
28660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28661   int jresult ;
28662   int result;
28663
28664   result = (int)Dali::Actor::Property::VISIBLE;
28665   jresult = (int)result;
28666   return jresult;
28667 }
28668
28669
28670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28671   int jresult ;
28672   int result;
28673
28674   result = (int)Dali::Actor::Property::COLOR;
28675   jresult = (int)result;
28676   return jresult;
28677 }
28678
28679
28680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28681   int jresult ;
28682   int result;
28683
28684   result = (int)Dali::Actor::Property::COLOR_RED;
28685   jresult = (int)result;
28686   return jresult;
28687 }
28688
28689
28690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28691   int jresult ;
28692   int result;
28693
28694   result = (int)Dali::Actor::Property::COLOR_GREEN;
28695   jresult = (int)result;
28696   return jresult;
28697 }
28698
28699
28700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28701   int jresult ;
28702   int result;
28703
28704   result = (int)Dali::Actor::Property::COLOR_BLUE;
28705   jresult = (int)result;
28706   return jresult;
28707 }
28708
28709
28710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
28711   int jresult ;
28712   int result;
28713
28714   result = (int)Dali::Actor::Property::COLOR_ALPHA;
28715   jresult = (int)result;
28716   return jresult;
28717 }
28718
28719
28720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
28721   int jresult ;
28722   int result;
28723
28724   result = (int)Dali::Actor::Property::WORLD_COLOR;
28725   jresult = (int)result;
28726   return jresult;
28727 }
28728
28729
28730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
28731   int jresult ;
28732   int result;
28733
28734   result = (int)Dali::Actor::Property::WORLD_MATRIX;
28735   jresult = (int)result;
28736   return jresult;
28737 }
28738
28739
28740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
28741   int jresult ;
28742   int result;
28743
28744   result = (int)Dali::Actor::Property::NAME;
28745   jresult = (int)result;
28746   return jresult;
28747 }
28748
28749
28750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
28751   int jresult ;
28752   int result;
28753
28754   result = (int)Dali::Actor::Property::SENSITIVE;
28755   jresult = (int)result;
28756   return jresult;
28757 }
28758
28759
28760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
28761   int jresult ;
28762   int result;
28763
28764   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
28765   jresult = (int)result;
28766   return jresult;
28767 }
28768
28769
28770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
28771   int jresult ;
28772   int result;
28773
28774   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
28775   jresult = (int)result;
28776   return jresult;
28777 }
28778
28779
28780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
28781   int jresult ;
28782   int result;
28783
28784   result = (int)Dali::Actor::Property::INHERIT_SCALE;
28785   jresult = (int)result;
28786   return jresult;
28787 }
28788
28789
28790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
28791   int jresult ;
28792   int result;
28793
28794   result = (int)Dali::Actor::Property::COLOR_MODE;
28795   jresult = (int)result;
28796   return jresult;
28797 }
28798
28799
28800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
28801   int jresult ;
28802   int result;
28803
28804   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
28805   jresult = (int)result;
28806   return jresult;
28807 }
28808
28809
28810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
28811   int jresult ;
28812   int result;
28813
28814   result = (int)Dali::Actor::Property::DRAW_MODE;
28815   jresult = (int)result;
28816   return jresult;
28817 }
28818
28819
28820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
28821   int jresult ;
28822   int result;
28823
28824   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
28825   jresult = (int)result;
28826   return jresult;
28827 }
28828
28829
28830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
28831   int jresult ;
28832   int result;
28833
28834   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
28835   jresult = (int)result;
28836   return jresult;
28837 }
28838
28839
28840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
28841   int jresult ;
28842   int result;
28843
28844   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
28845   jresult = (int)result;
28846   return jresult;
28847 }
28848
28849
28850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
28851   int jresult ;
28852   int result;
28853
28854   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
28855   jresult = (int)result;
28856   return jresult;
28857 }
28858
28859
28860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
28861   int jresult ;
28862   int result;
28863
28864   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
28865   jresult = (int)result;
28866   return jresult;
28867 }
28868
28869
28870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
28871   int jresult ;
28872   int result;
28873
28874   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
28875   jresult = (int)result;
28876   return jresult;
28877 }
28878
28879
28880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
28881   int jresult ;
28882   int result;
28883
28884   result = (int)Dali::Actor::Property::PADDING;
28885   jresult = (int)result;
28886   return jresult;
28887 }
28888
28889
28890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
28891   int jresult ;
28892   int result;
28893
28894   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
28895   jresult = (int)result;
28896   return jresult;
28897 }
28898
28899
28900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
28901   int jresult ;
28902   int result;
28903
28904   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
28905   jresult = (int)result;
28906   return jresult;
28907 }
28908
28909
28910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
28911   int jresult ;
28912   int result;
28913
28914   result = (int)Dali::Actor::Property::INHERIT_POSITION;
28915   jresult = (int)result;
28916   return jresult;
28917 }
28918
28919
28920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
28921   int jresult ;
28922   int result;
28923
28924   result = (int)Dali::Actor::Property::CLIPPING_MODE;
28925   jresult = (int)result;
28926   return jresult;
28927 }
28928
28929
28930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
28931   void * jresult ;
28932   Dali::Actor::Property *result = 0 ;
28933
28934   {
28935     try {
28936       result = (Dali::Actor::Property *)new Dali::Actor::Property();
28937     } catch (std::out_of_range& e) {
28938       {
28939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28940       };
28941     } catch (std::exception& e) {
28942       {
28943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28944       };
28945     } catch (...) {
28946       {
28947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28948       };
28949     }
28950   }
28951   jresult = (void *)result;
28952   return jresult;
28953 }
28954
28955
28956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
28957   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
28958
28959   arg1 = (Dali::Actor::Property *)jarg1;
28960   {
28961     try {
28962       delete arg1;
28963     } catch (std::out_of_range& e) {
28964       {
28965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28966       };
28967     } catch (std::exception& e) {
28968       {
28969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28970       };
28971     } catch (...) {
28972       {
28973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28974       };
28975     }
28976   }
28977 }
28978
28979
28980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
28981   void * jresult ;
28982   Dali::Actor *result = 0 ;
28983
28984   {
28985     try {
28986       result = (Dali::Actor *)new Dali::Actor();
28987     } catch (std::out_of_range& e) {
28988       {
28989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28990       };
28991     } catch (std::exception& e) {
28992       {
28993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28994       };
28995     } catch (...) {
28996       {
28997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28998       };
28999     }
29000   }
29001   jresult = (void *)result;
29002   return jresult;
29003 }
29004
29005
29006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29007   void * jresult ;
29008   Dali::Actor result;
29009
29010   {
29011     try {
29012       result = Dali::Actor::New();
29013     } catch (std::out_of_range& e) {
29014       {
29015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29016       };
29017     } catch (std::exception& e) {
29018       {
29019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29020       };
29021     } catch (...) {
29022       {
29023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29024       };
29025     }
29026   }
29027   jresult = new Dali::Actor((const Dali::Actor &)result);
29028   return jresult;
29029 }
29030
29031
29032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29033   void * jresult ;
29034   Dali::BaseHandle arg1 ;
29035   Dali::BaseHandle *argp1 ;
29036   Dali::Actor result;
29037
29038   argp1 = (Dali::BaseHandle *)jarg1;
29039   if (!argp1) {
29040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29041     return 0;
29042   }
29043   arg1 = *argp1;
29044   {
29045     try {
29046       result = Dali::Actor::DownCast(arg1);
29047     } catch (std::out_of_range& e) {
29048       {
29049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29050       };
29051     } catch (std::exception& e) {
29052       {
29053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29054       };
29055     } catch (...) {
29056       {
29057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29058       };
29059     }
29060   }
29061   jresult = new Dali::Actor((const Dali::Actor &)result);
29062   return jresult;
29063 }
29064
29065
29066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29067   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29068
29069   arg1 = (Dali::Actor *)jarg1;
29070   {
29071     try {
29072       delete arg1;
29073     } catch (std::out_of_range& e) {
29074       {
29075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29076       };
29077     } catch (std::exception& e) {
29078       {
29079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29080       };
29081     } catch (...) {
29082       {
29083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29084       };
29085     }
29086   }
29087 }
29088
29089
29090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29091   void * jresult ;
29092   Dali::Actor *arg1 = 0 ;
29093   Dali::Actor *result = 0 ;
29094
29095   arg1 = (Dali::Actor *)jarg1;
29096   if (!arg1) {
29097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29098     return 0;
29099   }
29100   {
29101     try {
29102       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29103     } catch (std::out_of_range& e) {
29104       {
29105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29106       };
29107     } catch (std::exception& e) {
29108       {
29109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29110       };
29111     } catch (...) {
29112       {
29113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29114       };
29115     }
29116   }
29117   jresult = (void *)result;
29118   return jresult;
29119 }
29120
29121
29122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29123   void * jresult ;
29124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29125   Dali::Actor *arg2 = 0 ;
29126   Dali::Actor *result = 0 ;
29127
29128   arg1 = (Dali::Actor *)jarg1;
29129   arg2 = (Dali::Actor *)jarg2;
29130   if (!arg2) {
29131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29132     return 0;
29133   }
29134   {
29135     try {
29136       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29137     } catch (std::out_of_range& e) {
29138       {
29139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29140       };
29141     } catch (std::exception& e) {
29142       {
29143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29144       };
29145     } catch (...) {
29146       {
29147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29148       };
29149     }
29150   }
29151   jresult = (void *)result;
29152   return jresult;
29153 }
29154
29155
29156 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29157   char * jresult ;
29158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29159   std::string *result = 0 ;
29160
29161   arg1 = (Dali::Actor *)jarg1;
29162   {
29163     try {
29164       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29165     } catch (std::out_of_range& e) {
29166       {
29167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29168       };
29169     } catch (std::exception& e) {
29170       {
29171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29172       };
29173     } catch (...) {
29174       {
29175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29176       };
29177     }
29178   }
29179   jresult = SWIG_csharp_string_callback(result->c_str());
29180   return jresult;
29181 }
29182
29183
29184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29186   std::string *arg2 = 0 ;
29187
29188   arg1 = (Dali::Actor *)jarg1;
29189   if (!jarg2) {
29190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29191     return ;
29192   }
29193   std::string arg2_str(jarg2);
29194   arg2 = &arg2_str;
29195   {
29196     try {
29197       (arg1)->SetName((std::string const &)*arg2);
29198     } catch (std::out_of_range& e) {
29199       {
29200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29201       };
29202     } catch (std::exception& e) {
29203       {
29204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29205       };
29206     } catch (...) {
29207       {
29208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29209       };
29210     }
29211   }
29212
29213   //argout typemap for const std::string&
29214
29215 }
29216
29217
29218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29219   unsigned int jresult ;
29220   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29221   unsigned int result;
29222
29223   arg1 = (Dali::Actor *)jarg1;
29224   {
29225     try {
29226       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29227     } catch (std::out_of_range& e) {
29228       {
29229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29230       };
29231     } catch (std::exception& e) {
29232       {
29233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29234       };
29235     } catch (...) {
29236       {
29237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29238       };
29239     }
29240   }
29241   jresult = result;
29242   return jresult;
29243 }
29244
29245
29246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29247   unsigned int jresult ;
29248   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29249   bool result;
29250
29251   arg1 = (Dali::Actor *)jarg1;
29252   {
29253     try {
29254       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29255     } catch (std::out_of_range& e) {
29256       {
29257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29258       };
29259     } catch (std::exception& e) {
29260       {
29261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29262       };
29263     } catch (...) {
29264       {
29265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29266       };
29267     }
29268   }
29269   jresult = result;
29270   return jresult;
29271 }
29272
29273
29274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29275   unsigned int jresult ;
29276   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29277   bool result;
29278
29279   arg1 = (Dali::Actor *)jarg1;
29280   {
29281     try {
29282       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29283     } catch (std::out_of_range& e) {
29284       {
29285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29286       };
29287     } catch (std::exception& e) {
29288       {
29289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29290       };
29291     } catch (...) {
29292       {
29293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29294       };
29295     }
29296   }
29297   jresult = result;
29298   return jresult;
29299 }
29300
29301
29302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29303   unsigned int jresult ;
29304   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29305   bool result;
29306
29307   arg1 = (Dali::Actor *)jarg1;
29308   {
29309     try {
29310       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
29311     } catch (std::out_of_range& e) {
29312       {
29313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29314       };
29315     } catch (std::exception& e) {
29316       {
29317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29318       };
29319     } catch (...) {
29320       {
29321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29322       };
29323     }
29324   }
29325   jresult = result;
29326   return jresult;
29327 }
29328
29329
29330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
29331   void * jresult ;
29332   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29333   Dali::Layer result;
29334
29335   arg1 = (Dali::Actor *)jarg1;
29336   {
29337     try {
29338       result = (arg1)->GetLayer();
29339     } catch (std::out_of_range& e) {
29340       {
29341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29342       };
29343     } catch (std::exception& e) {
29344       {
29345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29346       };
29347     } catch (...) {
29348       {
29349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29350       };
29351     }
29352   }
29353   jresult = new Dali::Layer((const Dali::Layer &)result);
29354   return jresult;
29355 }
29356
29357
29358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29360   Dali::Actor arg2 ;
29361   Dali::Actor *argp2 ;
29362
29363   arg1 = (Dali::Actor *)jarg1;
29364   argp2 = (Dali::Actor *)jarg2;
29365   if (!argp2) {
29366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29367     return ;
29368   }
29369   arg2 = *argp2;
29370   {
29371     try {
29372       (arg1)->Add(arg2);
29373     } catch (std::out_of_range& e) {
29374       {
29375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29376       };
29377     } catch (std::exception& e) {
29378       {
29379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29380       };
29381     } catch (...) {
29382       {
29383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29384       };
29385     }
29386   }
29387 }
29388
29389
29390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29391   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29392   Dali::Actor arg2 ;
29393   Dali::Actor *argp2 ;
29394
29395   arg1 = (Dali::Actor *)jarg1;
29396   argp2 = (Dali::Actor *)jarg2;
29397   if (!argp2) {
29398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29399     return ;
29400   }
29401   arg2 = *argp2;
29402   {
29403     try {
29404       (arg1)->Remove(arg2);
29405     } catch (std::out_of_range& e) {
29406       {
29407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29408       };
29409     } catch (std::exception& e) {
29410       {
29411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29412       };
29413     } catch (...) {
29414       {
29415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29416       };
29417     }
29418   }
29419 }
29420
29421
29422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29423   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29424
29425   arg1 = (Dali::Actor *)jarg1;
29426   {
29427     try {
29428       (arg1)->Unparent();
29429     } catch (std::out_of_range& e) {
29430       {
29431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29432       };
29433     } catch (std::exception& e) {
29434       {
29435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29436       };
29437     } catch (...) {
29438       {
29439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29440       };
29441     }
29442   }
29443 }
29444
29445
29446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29447   unsigned int jresult ;
29448   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29449   unsigned int result;
29450
29451   arg1 = (Dali::Actor *)jarg1;
29452   {
29453     try {
29454       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29455     } catch (std::out_of_range& e) {
29456       {
29457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29458       };
29459     } catch (std::exception& e) {
29460       {
29461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29462       };
29463     } catch (...) {
29464       {
29465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29466       };
29467     }
29468   }
29469   jresult = result;
29470   return jresult;
29471 }
29472
29473
29474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29475   void * jresult ;
29476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29477   unsigned int arg2 ;
29478   Dali::Actor result;
29479
29480   arg1 = (Dali::Actor *)jarg1;
29481   arg2 = (unsigned int)jarg2;
29482   {
29483     try {
29484       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29485     } catch (std::out_of_range& e) {
29486       {
29487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29488       };
29489     } catch (std::exception& e) {
29490       {
29491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29492       };
29493     } catch (...) {
29494       {
29495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29496       };
29497     }
29498   }
29499   jresult = new Dali::Actor((const Dali::Actor &)result);
29500   return jresult;
29501 }
29502
29503
29504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29505   void * jresult ;
29506   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29507   std::string *arg2 = 0 ;
29508   Dali::Actor result;
29509
29510   arg1 = (Dali::Actor *)jarg1;
29511   if (!jarg2) {
29512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29513     return 0;
29514   }
29515   std::string arg2_str(jarg2);
29516   arg2 = &arg2_str;
29517   {
29518     try {
29519       result = (arg1)->FindChildByName((std::string const &)*arg2);
29520     } catch (std::out_of_range& e) {
29521       {
29522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29523       };
29524     } catch (std::exception& e) {
29525       {
29526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29527       };
29528     } catch (...) {
29529       {
29530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29531       };
29532     }
29533   }
29534   jresult = new Dali::Actor((const Dali::Actor &)result);
29535
29536   //argout typemap for const std::string&
29537
29538   return jresult;
29539 }
29540
29541
29542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29543   void * jresult ;
29544   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29545   unsigned int arg2 ;
29546   Dali::Actor result;
29547
29548   arg1 = (Dali::Actor *)jarg1;
29549   arg2 = (unsigned int)jarg2;
29550   {
29551     try {
29552       result = (arg1)->FindChildById(arg2);
29553     } catch (std::out_of_range& e) {
29554       {
29555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29556       };
29557     } catch (std::exception& e) {
29558       {
29559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29560       };
29561     } catch (...) {
29562       {
29563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29564       };
29565     }
29566   }
29567   jresult = new Dali::Actor((const Dali::Actor &)result);
29568   return jresult;
29569 }
29570
29571
29572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29573   void * jresult ;
29574   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29575   Dali::Actor result;
29576
29577   arg1 = (Dali::Actor *)jarg1;
29578   {
29579     try {
29580       result = ((Dali::Actor const *)arg1)->GetParent();
29581     } catch (std::out_of_range& e) {
29582       {
29583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29584       };
29585     } catch (std::exception& e) {
29586       {
29587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29588       };
29589     } catch (...) {
29590       {
29591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29592       };
29593     }
29594   }
29595   jresult = new Dali::Actor((const Dali::Actor &)result);
29596   return jresult;
29597 }
29598
29599
29600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29601   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29602   Dali::Vector3 *arg2 = 0 ;
29603
29604   arg1 = (Dali::Actor *)jarg1;
29605   arg2 = (Dali::Vector3 *)jarg2;
29606   if (!arg2) {
29607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29608     return ;
29609   }
29610   {
29611     try {
29612       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
29613     } catch (std::out_of_range& e) {
29614       {
29615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29616       };
29617     } catch (std::exception& e) {
29618       {
29619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29620       };
29621     } catch (...) {
29622       {
29623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29624       };
29625     }
29626   }
29627 }
29628
29629
29630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
29631   void * jresult ;
29632   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29633   Dali::Vector3 result;
29634
29635   arg1 = (Dali::Actor *)jarg1;
29636   {
29637     try {
29638       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29639     } catch (std::out_of_range& e) {
29640       {
29641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29642       };
29643     } catch (std::exception& e) {
29644       {
29645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29646       };
29647     } catch (...) {
29648       {
29649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29650       };
29651     }
29652   }
29653   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29654   return jresult;
29655 }
29656
29657
29658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29660   Dali::Vector3 *arg2 = 0 ;
29661
29662   arg1 = (Dali::Actor *)jarg1;
29663   arg2 = (Dali::Vector3 *)jarg2;
29664   if (!arg2) {
29665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29666     return ;
29667   }
29668   {
29669     try {
29670       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29671     } catch (std::out_of_range& e) {
29672       {
29673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29674       };
29675     } catch (std::exception& e) {
29676       {
29677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29678       };
29679     } catch (...) {
29680       {
29681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29682       };
29683     }
29684   }
29685 }
29686
29687
29688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29689   void * jresult ;
29690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29691   Dali::Vector3 result;
29692
29693   arg1 = (Dali::Actor *)jarg1;
29694   {
29695     try {
29696       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29697     } catch (std::out_of_range& e) {
29698       {
29699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29700       };
29701     } catch (std::exception& e) {
29702       {
29703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29704       };
29705     } catch (...) {
29706       {
29707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29708       };
29709     }
29710   }
29711   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29712   return jresult;
29713 }
29714
29715
29716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29718   float arg2 ;
29719   float arg3 ;
29720
29721   arg1 = (Dali::Actor *)jarg1;
29722   arg2 = (float)jarg2;
29723   arg3 = (float)jarg3;
29724   {
29725     try {
29726       (arg1)->SetSize(arg2,arg3);
29727     } catch (std::out_of_range& e) {
29728       {
29729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29730       };
29731     } catch (std::exception& e) {
29732       {
29733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29734       };
29735     } catch (...) {
29736       {
29737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29738       };
29739     }
29740   }
29741 }
29742
29743
29744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29745   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29746   float arg2 ;
29747   float arg3 ;
29748   float arg4 ;
29749
29750   arg1 = (Dali::Actor *)jarg1;
29751   arg2 = (float)jarg2;
29752   arg3 = (float)jarg3;
29753   arg4 = (float)jarg4;
29754   {
29755     try {
29756       (arg1)->SetSize(arg2,arg3,arg4);
29757     } catch (std::out_of_range& e) {
29758       {
29759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29760       };
29761     } catch (std::exception& e) {
29762       {
29763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29764       };
29765     } catch (...) {
29766       {
29767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29768       };
29769     }
29770   }
29771 }
29772
29773
29774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
29775   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29776   Dali::Vector2 *arg2 = 0 ;
29777
29778   arg1 = (Dali::Actor *)jarg1;
29779   arg2 = (Dali::Vector2 *)jarg2;
29780   if (!arg2) {
29781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29782     return ;
29783   }
29784   {
29785     try {
29786       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
29787     } catch (std::out_of_range& e) {
29788       {
29789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29790       };
29791     } catch (std::exception& e) {
29792       {
29793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29794       };
29795     } catch (...) {
29796       {
29797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29798       };
29799     }
29800   }
29801 }
29802
29803
29804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
29805   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29806   Dali::Vector3 *arg2 = 0 ;
29807
29808   arg1 = (Dali::Actor *)jarg1;
29809   arg2 = (Dali::Vector3 *)jarg2;
29810   if (!arg2) {
29811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29812     return ;
29813   }
29814   {
29815     try {
29816       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
29817     } catch (std::out_of_range& e) {
29818       {
29819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29820       };
29821     } catch (std::exception& e) {
29822       {
29823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29824       };
29825     } catch (...) {
29826       {
29827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29828       };
29829     }
29830   }
29831 }
29832
29833
29834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
29835   void * jresult ;
29836   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29837   Dali::Vector3 result;
29838
29839   arg1 = (Dali::Actor *)jarg1;
29840   {
29841     try {
29842       result = ((Dali::Actor const *)arg1)->GetTargetSize();
29843     } catch (std::out_of_range& e) {
29844       {
29845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29846       };
29847     } catch (std::exception& e) {
29848       {
29849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29850       };
29851     } catch (...) {
29852       {
29853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29854       };
29855     }
29856   }
29857   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29858   return jresult;
29859 }
29860
29861
29862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
29863   void * jresult ;
29864   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29865   Dali::Vector3 result;
29866
29867   arg1 = (Dali::Actor *)jarg1;
29868   {
29869     try {
29870       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
29871     } catch (std::out_of_range& e) {
29872       {
29873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29874       };
29875     } catch (std::exception& e) {
29876       {
29877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29878       };
29879     } catch (...) {
29880       {
29881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29882       };
29883     }
29884   }
29885   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29886   return jresult;
29887 }
29888
29889
29890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
29891   void * jresult ;
29892   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29893   Dali::Vector3 result;
29894
29895   arg1 = (Dali::Actor *)jarg1;
29896   {
29897     try {
29898       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
29899     } catch (std::out_of_range& e) {
29900       {
29901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29902       };
29903     } catch (std::exception& e) {
29904       {
29905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29906       };
29907     } catch (...) {
29908       {
29909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29910       };
29911     }
29912   }
29913   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29914   return jresult;
29915 }
29916
29917
29918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29919   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29920   float arg2 ;
29921   float arg3 ;
29922
29923   arg1 = (Dali::Actor *)jarg1;
29924   arg2 = (float)jarg2;
29925   arg3 = (float)jarg3;
29926   {
29927     try {
29928       (arg1)->SetPosition(arg2,arg3);
29929     } catch (std::out_of_range& e) {
29930       {
29931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29932       };
29933     } catch (std::exception& e) {
29934       {
29935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29936       };
29937     } catch (...) {
29938       {
29939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29940       };
29941     }
29942   }
29943 }
29944
29945
29946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29947   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29948   float arg2 ;
29949   float arg3 ;
29950   float arg4 ;
29951
29952   arg1 = (Dali::Actor *)jarg1;
29953   arg2 = (float)jarg2;
29954   arg3 = (float)jarg3;
29955   arg4 = (float)jarg4;
29956   {
29957     try {
29958       (arg1)->SetPosition(arg2,arg3,arg4);
29959     } catch (std::out_of_range& e) {
29960       {
29961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29962       };
29963     } catch (std::exception& e) {
29964       {
29965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29966       };
29967     } catch (...) {
29968       {
29969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29970       };
29971     }
29972   }
29973 }
29974
29975
29976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
29977   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29978   Dali::Vector3 *arg2 = 0 ;
29979
29980   arg1 = (Dali::Actor *)jarg1;
29981   arg2 = (Dali::Vector3 *)jarg2;
29982   if (!arg2) {
29983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29984     return ;
29985   }
29986   {
29987     try {
29988       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
29989     } catch (std::out_of_range& e) {
29990       {
29991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29992       };
29993     } catch (std::exception& e) {
29994       {
29995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29996       };
29997     } catch (...) {
29998       {
29999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30000       };
30001     }
30002   }
30003 }
30004
30005
30006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30007   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30008   float arg2 ;
30009
30010   arg1 = (Dali::Actor *)jarg1;
30011   arg2 = (float)jarg2;
30012   {
30013     try {
30014       (arg1)->SetX(arg2);
30015     } catch (std::out_of_range& e) {
30016       {
30017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30018       };
30019     } catch (std::exception& e) {
30020       {
30021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30022       };
30023     } catch (...) {
30024       {
30025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30026       };
30027     }
30028   }
30029 }
30030
30031
30032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30033   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30034   float arg2 ;
30035
30036   arg1 = (Dali::Actor *)jarg1;
30037   arg2 = (float)jarg2;
30038   {
30039     try {
30040       (arg1)->SetY(arg2);
30041     } catch (std::out_of_range& e) {
30042       {
30043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30044       };
30045     } catch (std::exception& e) {
30046       {
30047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30048       };
30049     } catch (...) {
30050       {
30051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30052       };
30053     }
30054   }
30055 }
30056
30057
30058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30059   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30060   float arg2 ;
30061
30062   arg1 = (Dali::Actor *)jarg1;
30063   arg2 = (float)jarg2;
30064   {
30065     try {
30066       (arg1)->SetZ(arg2);
30067     } catch (std::out_of_range& e) {
30068       {
30069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30070       };
30071     } catch (std::exception& e) {
30072       {
30073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30074       };
30075     } catch (...) {
30076       {
30077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30078       };
30079     }
30080   }
30081 }
30082
30083
30084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30085   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30086   Dali::Vector3 *arg2 = 0 ;
30087
30088   arg1 = (Dali::Actor *)jarg1;
30089   arg2 = (Dali::Vector3 *)jarg2;
30090   if (!arg2) {
30091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30092     return ;
30093   }
30094   {
30095     try {
30096       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30097     } catch (std::out_of_range& e) {
30098       {
30099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30100       };
30101     } catch (std::exception& e) {
30102       {
30103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30104       };
30105     } catch (...) {
30106       {
30107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30108       };
30109     }
30110   }
30111 }
30112
30113
30114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30115   void * jresult ;
30116   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30117   Dali::Vector3 result;
30118
30119   arg1 = (Dali::Actor *)jarg1;
30120   {
30121     try {
30122       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30123     } catch (std::out_of_range& e) {
30124       {
30125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30126       };
30127     } catch (std::exception& e) {
30128       {
30129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30130       };
30131     } catch (...) {
30132       {
30133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30134       };
30135     }
30136   }
30137   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30138   return jresult;
30139 }
30140
30141
30142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30143   void * jresult ;
30144   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30145   Dali::Vector3 result;
30146
30147   arg1 = (Dali::Actor *)jarg1;
30148   {
30149     try {
30150       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30151     } catch (std::out_of_range& e) {
30152       {
30153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30154       };
30155     } catch (std::exception& e) {
30156       {
30157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30158       };
30159     } catch (...) {
30160       {
30161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30162       };
30163     }
30164   }
30165   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30166   return jresult;
30167 }
30168
30169
30170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30171   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30172   bool arg2 ;
30173
30174   arg1 = (Dali::Actor *)jarg1;
30175   arg2 = jarg2 ? true : false;
30176   {
30177     try {
30178       (arg1)->SetInheritPosition(arg2);
30179     } catch (std::out_of_range& e) {
30180       {
30181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30182       };
30183     } catch (std::exception& e) {
30184       {
30185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30186       };
30187     } catch (...) {
30188       {
30189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30190       };
30191     }
30192   }
30193 }
30194
30195
30196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30197   int jresult ;
30198   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30199   Dali::PositionInheritanceMode result;
30200
30201   arg1 = (Dali::Actor *)jarg1;
30202   {
30203     try {
30204       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30205     } catch (std::out_of_range& e) {
30206       {
30207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30208       };
30209     } catch (std::exception& e) {
30210       {
30211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30212       };
30213     } catch (...) {
30214       {
30215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30216       };
30217     }
30218   }
30219   jresult = (int)result;
30220   return jresult;
30221 }
30222
30223
30224 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30225   unsigned int jresult ;
30226   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30227   bool result;
30228
30229   arg1 = (Dali::Actor *)jarg1;
30230   {
30231     try {
30232       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30233     } catch (std::out_of_range& e) {
30234       {
30235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30236       };
30237     } catch (std::exception& e) {
30238       {
30239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30240       };
30241     } catch (...) {
30242       {
30243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30244       };
30245     }
30246   }
30247   jresult = result;
30248   return jresult;
30249 }
30250
30251
30252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30253   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30254   Dali::Degree *arg2 = 0 ;
30255   Dali::Vector3 *arg3 = 0 ;
30256
30257   arg1 = (Dali::Actor *)jarg1;
30258   arg2 = (Dali::Degree *)jarg2;
30259   if (!arg2) {
30260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30261     return ;
30262   }
30263   arg3 = (Dali::Vector3 *)jarg3;
30264   if (!arg3) {
30265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30266     return ;
30267   }
30268   {
30269     try {
30270       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30271     } catch (std::out_of_range& e) {
30272       {
30273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30274       };
30275     } catch (std::exception& e) {
30276       {
30277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30278       };
30279     } catch (...) {
30280       {
30281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30282       };
30283     }
30284   }
30285 }
30286
30287
30288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30289   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30290   Dali::Radian *arg2 = 0 ;
30291   Dali::Vector3 *arg3 = 0 ;
30292
30293   arg1 = (Dali::Actor *)jarg1;
30294   arg2 = (Dali::Radian *)jarg2;
30295   if (!arg2) {
30296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30297     return ;
30298   }
30299   arg3 = (Dali::Vector3 *)jarg3;
30300   if (!arg3) {
30301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30302     return ;
30303   }
30304   {
30305     try {
30306       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30307     } catch (std::out_of_range& e) {
30308       {
30309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30310       };
30311     } catch (std::exception& e) {
30312       {
30313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30314       };
30315     } catch (...) {
30316       {
30317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30318       };
30319     }
30320   }
30321 }
30322
30323
30324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30326   Dali::Quaternion *arg2 = 0 ;
30327
30328   arg1 = (Dali::Actor *)jarg1;
30329   arg2 = (Dali::Quaternion *)jarg2;
30330   if (!arg2) {
30331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30332     return ;
30333   }
30334   {
30335     try {
30336       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30337     } catch (std::out_of_range& e) {
30338       {
30339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30340       };
30341     } catch (std::exception& e) {
30342       {
30343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30344       };
30345     } catch (...) {
30346       {
30347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30348       };
30349     }
30350   }
30351 }
30352
30353
30354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30355   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30356   Dali::Degree *arg2 = 0 ;
30357   Dali::Vector3 *arg3 = 0 ;
30358
30359   arg1 = (Dali::Actor *)jarg1;
30360   arg2 = (Dali::Degree *)jarg2;
30361   if (!arg2) {
30362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30363     return ;
30364   }
30365   arg3 = (Dali::Vector3 *)jarg3;
30366   if (!arg3) {
30367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30368     return ;
30369   }
30370   {
30371     try {
30372       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30373     } catch (std::out_of_range& e) {
30374       {
30375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30376       };
30377     } catch (std::exception& e) {
30378       {
30379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30380       };
30381     } catch (...) {
30382       {
30383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30384       };
30385     }
30386   }
30387 }
30388
30389
30390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30391   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30392   Dali::Radian *arg2 = 0 ;
30393   Dali::Vector3 *arg3 = 0 ;
30394
30395   arg1 = (Dali::Actor *)jarg1;
30396   arg2 = (Dali::Radian *)jarg2;
30397   if (!arg2) {
30398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30399     return ;
30400   }
30401   arg3 = (Dali::Vector3 *)jarg3;
30402   if (!arg3) {
30403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30404     return ;
30405   }
30406   {
30407     try {
30408       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30409     } catch (std::out_of_range& e) {
30410       {
30411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30412       };
30413     } catch (std::exception& e) {
30414       {
30415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30416       };
30417     } catch (...) {
30418       {
30419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30420       };
30421     }
30422   }
30423 }
30424
30425
30426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30427   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30428   Dali::Quaternion *arg2 = 0 ;
30429
30430   arg1 = (Dali::Actor *)jarg1;
30431   arg2 = (Dali::Quaternion *)jarg2;
30432   if (!arg2) {
30433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30434     return ;
30435   }
30436   {
30437     try {
30438       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30439     } catch (std::out_of_range& e) {
30440       {
30441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30442       };
30443     } catch (std::exception& e) {
30444       {
30445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30446       };
30447     } catch (...) {
30448       {
30449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30450       };
30451     }
30452   }
30453 }
30454
30455
30456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30457   void * jresult ;
30458   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30459   Dali::Quaternion result;
30460
30461   arg1 = (Dali::Actor *)jarg1;
30462   {
30463     try {
30464       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30465     } catch (std::out_of_range& e) {
30466       {
30467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30468       };
30469     } catch (std::exception& e) {
30470       {
30471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30472       };
30473     } catch (...) {
30474       {
30475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30476       };
30477     }
30478   }
30479   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30480   return jresult;
30481 }
30482
30483
30484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30485   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30486   bool arg2 ;
30487
30488   arg1 = (Dali::Actor *)jarg1;
30489   arg2 = jarg2 ? true : false;
30490   {
30491     try {
30492       (arg1)->SetInheritOrientation(arg2);
30493     } catch (std::out_of_range& e) {
30494       {
30495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30496       };
30497     } catch (std::exception& e) {
30498       {
30499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30500       };
30501     } catch (...) {
30502       {
30503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30504       };
30505     }
30506   }
30507 }
30508
30509
30510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30511   unsigned int jresult ;
30512   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30513   bool result;
30514
30515   arg1 = (Dali::Actor *)jarg1;
30516   {
30517     try {
30518       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30519     } catch (std::out_of_range& e) {
30520       {
30521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30522       };
30523     } catch (std::exception& e) {
30524       {
30525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30526       };
30527     } catch (...) {
30528       {
30529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30530       };
30531     }
30532   }
30533   jresult = result;
30534   return jresult;
30535 }
30536
30537
30538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30539   void * jresult ;
30540   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30541   Dali::Quaternion result;
30542
30543   arg1 = (Dali::Actor *)jarg1;
30544   {
30545     try {
30546       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
30547     } catch (std::out_of_range& e) {
30548       {
30549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30550       };
30551     } catch (std::exception& e) {
30552       {
30553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30554       };
30555     } catch (...) {
30556       {
30557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30558       };
30559     }
30560   }
30561   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30562   return jresult;
30563 }
30564
30565
30566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30568   float arg2 ;
30569
30570   arg1 = (Dali::Actor *)jarg1;
30571   arg2 = (float)jarg2;
30572   {
30573     try {
30574       (arg1)->SetScale(arg2);
30575     } catch (std::out_of_range& e) {
30576       {
30577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30578       };
30579     } catch (std::exception& e) {
30580       {
30581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30582       };
30583     } catch (...) {
30584       {
30585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30586       };
30587     }
30588   }
30589 }
30590
30591
30592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30593   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30594   float arg2 ;
30595   float arg3 ;
30596   float arg4 ;
30597
30598   arg1 = (Dali::Actor *)jarg1;
30599   arg2 = (float)jarg2;
30600   arg3 = (float)jarg3;
30601   arg4 = (float)jarg4;
30602   {
30603     try {
30604       (arg1)->SetScale(arg2,arg3,arg4);
30605     } catch (std::out_of_range& e) {
30606       {
30607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30608       };
30609     } catch (std::exception& e) {
30610       {
30611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30612       };
30613     } catch (...) {
30614       {
30615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30616       };
30617     }
30618   }
30619 }
30620
30621
30622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30623   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30624   Dali::Vector3 *arg2 = 0 ;
30625
30626   arg1 = (Dali::Actor *)jarg1;
30627   arg2 = (Dali::Vector3 *)jarg2;
30628   if (!arg2) {
30629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30630     return ;
30631   }
30632   {
30633     try {
30634       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30635     } catch (std::out_of_range& e) {
30636       {
30637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30638       };
30639     } catch (std::exception& e) {
30640       {
30641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30642       };
30643     } catch (...) {
30644       {
30645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30646       };
30647     }
30648   }
30649 }
30650
30651
30652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30654   Dali::Vector3 *arg2 = 0 ;
30655
30656   arg1 = (Dali::Actor *)jarg1;
30657   arg2 = (Dali::Vector3 *)jarg2;
30658   if (!arg2) {
30659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30660     return ;
30661   }
30662   {
30663     try {
30664       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30665     } catch (std::out_of_range& e) {
30666       {
30667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30668       };
30669     } catch (std::exception& e) {
30670       {
30671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30672       };
30673     } catch (...) {
30674       {
30675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30676       };
30677     }
30678   }
30679 }
30680
30681
30682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30683   void * jresult ;
30684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30685   Dali::Vector3 result;
30686
30687   arg1 = (Dali::Actor *)jarg1;
30688   {
30689     try {
30690       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30691     } catch (std::out_of_range& e) {
30692       {
30693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30694       };
30695     } catch (std::exception& e) {
30696       {
30697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30698       };
30699     } catch (...) {
30700       {
30701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30702       };
30703     }
30704   }
30705   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30706   return jresult;
30707 }
30708
30709
30710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
30711   void * jresult ;
30712   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30713   Dali::Vector3 result;
30714
30715   arg1 = (Dali::Actor *)jarg1;
30716   {
30717     try {
30718       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
30719     } catch (std::out_of_range& e) {
30720       {
30721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30722       };
30723     } catch (std::exception& e) {
30724       {
30725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30726       };
30727     } catch (...) {
30728       {
30729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30730       };
30731     }
30732   }
30733   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30734   return jresult;
30735 }
30736
30737
30738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
30739   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30740   bool arg2 ;
30741
30742   arg1 = (Dali::Actor *)jarg1;
30743   arg2 = jarg2 ? true : false;
30744   {
30745     try {
30746       (arg1)->SetInheritScale(arg2);
30747     } catch (std::out_of_range& e) {
30748       {
30749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30750       };
30751     } catch (std::exception& e) {
30752       {
30753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30754       };
30755     } catch (...) {
30756       {
30757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30758       };
30759     }
30760   }
30761 }
30762
30763
30764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
30765   unsigned int jresult ;
30766   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30767   bool result;
30768
30769   arg1 = (Dali::Actor *)jarg1;
30770   {
30771     try {
30772       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
30773     } catch (std::out_of_range& e) {
30774       {
30775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30776       };
30777     } catch (std::exception& e) {
30778       {
30779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30780       };
30781     } catch (...) {
30782       {
30783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30784       };
30785     }
30786   }
30787   jresult = result;
30788   return jresult;
30789 }
30790
30791
30792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
30793   void * jresult ;
30794   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30795   Dali::Matrix result;
30796
30797   arg1 = (Dali::Actor *)jarg1;
30798   {
30799     try {
30800       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
30801     } catch (std::out_of_range& e) {
30802       {
30803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30804       };
30805     } catch (std::exception& e) {
30806       {
30807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30808       };
30809     } catch (...) {
30810       {
30811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30812       };
30813     }
30814   }
30815   jresult = new Dali::Matrix((const Dali::Matrix &)result);
30816   return jresult;
30817 }
30818
30819
30820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
30821   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30822   bool arg2 ;
30823
30824   arg1 = (Dali::Actor *)jarg1;
30825   arg2 = jarg2 ? true : false;
30826   {
30827     try {
30828       (arg1)->SetVisible(arg2);
30829     } catch (std::out_of_range& e) {
30830       {
30831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30832       };
30833     } catch (std::exception& e) {
30834       {
30835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30836       };
30837     } catch (...) {
30838       {
30839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30840       };
30841     }
30842   }
30843 }
30844
30845
30846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
30847   unsigned int jresult ;
30848   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30849   bool result;
30850
30851   arg1 = (Dali::Actor *)jarg1;
30852   {
30853     try {
30854       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
30855     } catch (std::out_of_range& e) {
30856       {
30857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30858       };
30859     } catch (std::exception& e) {
30860       {
30861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30862       };
30863     } catch (...) {
30864       {
30865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30866       };
30867     }
30868   }
30869   jresult = result;
30870   return jresult;
30871 }
30872
30873
30874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
30875   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30876   float arg2 ;
30877
30878   arg1 = (Dali::Actor *)jarg1;
30879   arg2 = (float)jarg2;
30880   {
30881     try {
30882       (arg1)->SetOpacity(arg2);
30883     } catch (std::out_of_range& e) {
30884       {
30885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30886       };
30887     } catch (std::exception& e) {
30888       {
30889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30890       };
30891     } catch (...) {
30892       {
30893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30894       };
30895     }
30896   }
30897 }
30898
30899
30900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
30901   float jresult ;
30902   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30903   float result;
30904
30905   arg1 = (Dali::Actor *)jarg1;
30906   {
30907     try {
30908       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
30909     } catch (std::out_of_range& e) {
30910       {
30911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30912       };
30913     } catch (std::exception& e) {
30914       {
30915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30916       };
30917     } catch (...) {
30918       {
30919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30920       };
30921     }
30922   }
30923   jresult = result;
30924   return jresult;
30925 }
30926
30927
30928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
30929   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30930   Dali::Vector4 *arg2 = 0 ;
30931
30932   arg1 = (Dali::Actor *)jarg1;
30933   arg2 = (Dali::Vector4 *)jarg2;
30934   if (!arg2) {
30935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
30936     return ;
30937   }
30938   {
30939     try {
30940       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
30941     } catch (std::out_of_range& e) {
30942       {
30943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30944       };
30945     } catch (std::exception& e) {
30946       {
30947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30948       };
30949     } catch (...) {
30950       {
30951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30952       };
30953     }
30954   }
30955 }
30956
30957
30958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
30959   void * jresult ;
30960   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30961   Dali::Vector4 result;
30962
30963   arg1 = (Dali::Actor *)jarg1;
30964   {
30965     try {
30966       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
30967     } catch (std::out_of_range& e) {
30968       {
30969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30970       };
30971     } catch (std::exception& e) {
30972       {
30973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30974       };
30975     } catch (...) {
30976       {
30977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30978       };
30979     }
30980   }
30981   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
30982   return jresult;
30983 }
30984
30985
30986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
30987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30988   Dali::ColorMode arg2 ;
30989
30990   arg1 = (Dali::Actor *)jarg1;
30991   arg2 = (Dali::ColorMode)jarg2;
30992   {
30993     try {
30994       (arg1)->SetColorMode(arg2);
30995     } catch (std::out_of_range& e) {
30996       {
30997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30998       };
30999     } catch (std::exception& e) {
31000       {
31001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31002       };
31003     } catch (...) {
31004       {
31005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31006       };
31007     }
31008   }
31009 }
31010
31011
31012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31013   int jresult ;
31014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31015   Dali::ColorMode result;
31016
31017   arg1 = (Dali::Actor *)jarg1;
31018   {
31019     try {
31020       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31021     } catch (std::out_of_range& e) {
31022       {
31023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31024       };
31025     } catch (std::exception& e) {
31026       {
31027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31028       };
31029     } catch (...) {
31030       {
31031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31032       };
31033     }
31034   }
31035   jresult = (int)result;
31036   return jresult;
31037 }
31038
31039
31040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31041   void * jresult ;
31042   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31043   Dali::Vector4 result;
31044
31045   arg1 = (Dali::Actor *)jarg1;
31046   {
31047     try {
31048       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
31049     } catch (std::out_of_range& e) {
31050       {
31051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31052       };
31053     } catch (std::exception& e) {
31054       {
31055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31056       };
31057     } catch (...) {
31058       {
31059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31060       };
31061     }
31062   }
31063   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31064   return jresult;
31065 }
31066
31067
31068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31070   Dali::DrawMode::Type arg2 ;
31071
31072   arg1 = (Dali::Actor *)jarg1;
31073   arg2 = (Dali::DrawMode::Type)jarg2;
31074   {
31075     try {
31076       (arg1)->SetDrawMode(arg2);
31077     } catch (std::out_of_range& e) {
31078       {
31079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31080       };
31081     } catch (std::exception& e) {
31082       {
31083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31084       };
31085     } catch (...) {
31086       {
31087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31088       };
31089     }
31090   }
31091 }
31092
31093
31094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31095   int jresult ;
31096   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31097   Dali::DrawMode::Type result;
31098
31099   arg1 = (Dali::Actor *)jarg1;
31100   {
31101     try {
31102       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
31103     } catch (std::out_of_range& e) {
31104       {
31105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31106       };
31107     } catch (std::exception& e) {
31108       {
31109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31110       };
31111     } catch (...) {
31112       {
31113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31114       };
31115     }
31116   }
31117   jresult = (int)result;
31118   return jresult;
31119 }
31120
31121
31122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
31123   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31124   bool arg2 ;
31125
31126   arg1 = (Dali::Actor *)jarg1;
31127   arg2 = jarg2 ? true : false;
31128   {
31129     try {
31130       (arg1)->SetSensitive(arg2);
31131     } catch (std::out_of_range& e) {
31132       {
31133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31134       };
31135     } catch (std::exception& e) {
31136       {
31137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31138       };
31139     } catch (...) {
31140       {
31141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31142       };
31143     }
31144   }
31145 }
31146
31147
31148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
31149   unsigned int jresult ;
31150   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31151   bool result;
31152
31153   arg1 = (Dali::Actor *)jarg1;
31154   {
31155     try {
31156       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
31157     } catch (std::out_of_range& e) {
31158       {
31159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31160       };
31161     } catch (std::exception& e) {
31162       {
31163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31164       };
31165     } catch (...) {
31166       {
31167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31168       };
31169     }
31170   }
31171   jresult = result;
31172   return jresult;
31173 }
31174
31175
31176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31177   unsigned int jresult ;
31178   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31179   float *arg2 = 0 ;
31180   float *arg3 = 0 ;
31181   float arg4 ;
31182   float arg5 ;
31183   bool result;
31184
31185   arg1 = (Dali::Actor *)jarg1;
31186   arg2 = (float *)jarg2;
31187   arg3 = (float *)jarg3;
31188   arg4 = (float)jarg4;
31189   arg5 = (float)jarg5;
31190   {
31191     try {
31192       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31193     } catch (std::out_of_range& e) {
31194       {
31195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31196       };
31197     } catch (std::exception& e) {
31198       {
31199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31200       };
31201     } catch (...) {
31202       {
31203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31204       };
31205     }
31206   }
31207   jresult = result;
31208   return jresult;
31209 }
31210
31211
31212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31214   bool arg2 ;
31215
31216   arg1 = (Dali::Actor *)jarg1;
31217   arg2 = jarg2 ? true : false;
31218   {
31219     try {
31220       (arg1)->SetLeaveRequired(arg2);
31221     } catch (std::out_of_range& e) {
31222       {
31223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31224       };
31225     } catch (std::exception& e) {
31226       {
31227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31228       };
31229     } catch (...) {
31230       {
31231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31232       };
31233     }
31234   }
31235 }
31236
31237
31238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31239   unsigned int jresult ;
31240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31241   bool result;
31242
31243   arg1 = (Dali::Actor *)jarg1;
31244   {
31245     try {
31246       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31247     } catch (std::out_of_range& e) {
31248       {
31249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31250       };
31251     } catch (std::exception& e) {
31252       {
31253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31254       };
31255     } catch (...) {
31256       {
31257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31258       };
31259     }
31260   }
31261   jresult = result;
31262   return jresult;
31263 }
31264
31265
31266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31267   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31268   bool arg2 ;
31269
31270   arg1 = (Dali::Actor *)jarg1;
31271   arg2 = jarg2 ? true : false;
31272   {
31273     try {
31274       (arg1)->SetKeyboardFocusable(arg2);
31275     } catch (std::out_of_range& e) {
31276       {
31277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31278       };
31279     } catch (std::exception& e) {
31280       {
31281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31282       };
31283     } catch (...) {
31284       {
31285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31286       };
31287     }
31288   }
31289 }
31290
31291
31292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31293   unsigned int jresult ;
31294   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31295   bool result;
31296
31297   arg1 = (Dali::Actor *)jarg1;
31298   {
31299     try {
31300       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31301     } catch (std::out_of_range& e) {
31302       {
31303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31304       };
31305     } catch (std::exception& e) {
31306       {
31307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31308       };
31309     } catch (...) {
31310       {
31311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31312       };
31313     }
31314   }
31315   jresult = result;
31316   return jresult;
31317 }
31318
31319
31320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31322   Dali::ResizePolicy::Type arg2 ;
31323   Dali::Dimension::Type arg3 ;
31324
31325   arg1 = (Dali::Actor *)jarg1;
31326   arg2 = (Dali::ResizePolicy::Type)jarg2;
31327   arg3 = (Dali::Dimension::Type)jarg3;
31328   {
31329     try {
31330       (arg1)->SetResizePolicy(arg2,arg3);
31331     } catch (std::out_of_range& e) {
31332       {
31333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31334       };
31335     } catch (std::exception& e) {
31336       {
31337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31338       };
31339     } catch (...) {
31340       {
31341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31342       };
31343     }
31344   }
31345 }
31346
31347
31348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31349   int jresult ;
31350   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31351   Dali::Dimension::Type arg2 ;
31352   Dali::ResizePolicy::Type result;
31353
31354   arg1 = (Dali::Actor *)jarg1;
31355   arg2 = (Dali::Dimension::Type)jarg2;
31356   {
31357     try {
31358       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31359     } catch (std::out_of_range& e) {
31360       {
31361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31362       };
31363     } catch (std::exception& e) {
31364       {
31365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31366       };
31367     } catch (...) {
31368       {
31369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31370       };
31371     }
31372   }
31373   jresult = (int)result;
31374   return jresult;
31375 }
31376
31377
31378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31380   Dali::SizeScalePolicy::Type arg2 ;
31381
31382   arg1 = (Dali::Actor *)jarg1;
31383   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31384   {
31385     try {
31386       (arg1)->SetSizeScalePolicy(arg2);
31387     } catch (std::out_of_range& e) {
31388       {
31389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31390       };
31391     } catch (std::exception& e) {
31392       {
31393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31394       };
31395     } catch (...) {
31396       {
31397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31398       };
31399     }
31400   }
31401 }
31402
31403
31404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31405   int jresult ;
31406   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31407   Dali::SizeScalePolicy::Type result;
31408
31409   arg1 = (Dali::Actor *)jarg1;
31410   {
31411     try {
31412       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31413     } catch (std::out_of_range& e) {
31414       {
31415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31416       };
31417     } catch (std::exception& e) {
31418       {
31419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31420       };
31421     } catch (...) {
31422       {
31423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31424       };
31425     }
31426   }
31427   jresult = (int)result;
31428   return jresult;
31429 }
31430
31431
31432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31433   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31434   Dali::Vector3 *arg2 = 0 ;
31435
31436   arg1 = (Dali::Actor *)jarg1;
31437   arg2 = (Dali::Vector3 *)jarg2;
31438   if (!arg2) {
31439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31440     return ;
31441   }
31442   {
31443     try {
31444       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31445     } catch (std::out_of_range& e) {
31446       {
31447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31448       };
31449     } catch (std::exception& e) {
31450       {
31451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31452       };
31453     } catch (...) {
31454       {
31455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31456       };
31457     }
31458   }
31459 }
31460
31461
31462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31463   void * jresult ;
31464   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31465   Dali::Vector3 result;
31466
31467   arg1 = (Dali::Actor *)jarg1;
31468   {
31469     try {
31470       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31471     } catch (std::out_of_range& e) {
31472       {
31473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31474       };
31475     } catch (std::exception& e) {
31476       {
31477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31478       };
31479     } catch (...) {
31480       {
31481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31482       };
31483     }
31484   }
31485   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31486   return jresult;
31487 }
31488
31489
31490 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31491   float jresult ;
31492   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31493   float arg2 ;
31494   float result;
31495
31496   arg1 = (Dali::Actor *)jarg1;
31497   arg2 = (float)jarg2;
31498   {
31499     try {
31500       result = (float)(arg1)->GetHeightForWidth(arg2);
31501     } catch (std::out_of_range& e) {
31502       {
31503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31504       };
31505     } catch (std::exception& e) {
31506       {
31507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31508       };
31509     } catch (...) {
31510       {
31511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31512       };
31513     }
31514   }
31515   jresult = result;
31516   return jresult;
31517 }
31518
31519
31520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31521   float jresult ;
31522   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31523   float arg2 ;
31524   float result;
31525
31526   arg1 = (Dali::Actor *)jarg1;
31527   arg2 = (float)jarg2;
31528   {
31529     try {
31530       result = (float)(arg1)->GetWidthForHeight(arg2);
31531     } catch (std::out_of_range& e) {
31532       {
31533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31534       };
31535     } catch (std::exception& e) {
31536       {
31537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31538       };
31539     } catch (...) {
31540       {
31541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31542       };
31543     }
31544   }
31545   jresult = result;
31546   return jresult;
31547 }
31548
31549
31550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31551   float jresult ;
31552   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31553   Dali::Dimension::Type arg2 ;
31554   float result;
31555
31556   arg1 = (Dali::Actor *)jarg1;
31557   arg2 = (Dali::Dimension::Type)jarg2;
31558   {
31559     try {
31560       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31561     } catch (std::out_of_range& e) {
31562       {
31563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31564       };
31565     } catch (std::exception& e) {
31566       {
31567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31568       };
31569     } catch (...) {
31570       {
31571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31572       };
31573     }
31574   }
31575   jresult = result;
31576   return jresult;
31577 }
31578
31579
31580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31581   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31582   Dali::Padding *arg2 = 0 ;
31583
31584   arg1 = (Dali::Actor *)jarg1;
31585   arg2 = (Dali::Padding *)jarg2;
31586   if (!arg2) {
31587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31588     return ;
31589   }
31590   {
31591     try {
31592       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31593     } catch (std::out_of_range& e) {
31594       {
31595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31596       };
31597     } catch (std::exception& e) {
31598       {
31599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31600       };
31601     } catch (...) {
31602       {
31603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31604       };
31605     }
31606   }
31607 }
31608
31609
31610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31611   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31612   Dali::Padding *arg2 = 0 ;
31613
31614   arg1 = (Dali::Actor *)jarg1;
31615   arg2 = (Dali::Padding *)jarg2;
31616   if (!arg2) {
31617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31618     return ;
31619   }
31620   {
31621     try {
31622       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31623     } catch (std::out_of_range& e) {
31624       {
31625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31626       };
31627     } catch (std::exception& e) {
31628       {
31629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31630       };
31631     } catch (...) {
31632       {
31633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31634       };
31635     }
31636   }
31637 }
31638
31639
31640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31641   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31642   Dali::Vector2 *arg2 = 0 ;
31643
31644   arg1 = (Dali::Actor *)jarg1;
31645   arg2 = (Dali::Vector2 *)jarg2;
31646   if (!arg2) {
31647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31648     return ;
31649   }
31650   {
31651     try {
31652       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31653     } catch (std::out_of_range& e) {
31654       {
31655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31656       };
31657     } catch (std::exception& e) {
31658       {
31659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31660       };
31661     } catch (...) {
31662       {
31663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31664       };
31665     }
31666   }
31667 }
31668
31669
31670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31671   void * jresult ;
31672   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31673   Dali::Vector2 result;
31674
31675   arg1 = (Dali::Actor *)jarg1;
31676   {
31677     try {
31678       result = (arg1)->GetMinimumSize();
31679     } catch (std::out_of_range& e) {
31680       {
31681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31682       };
31683     } catch (std::exception& e) {
31684       {
31685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31686       };
31687     } catch (...) {
31688       {
31689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31690       };
31691     }
31692   }
31693   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31694   return jresult;
31695 }
31696
31697
31698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31699   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31700   Dali::Vector2 *arg2 = 0 ;
31701
31702   arg1 = (Dali::Actor *)jarg1;
31703   arg2 = (Dali::Vector2 *)jarg2;
31704   if (!arg2) {
31705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31706     return ;
31707   }
31708   {
31709     try {
31710       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
31711     } catch (std::out_of_range& e) {
31712       {
31713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31714       };
31715     } catch (std::exception& e) {
31716       {
31717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31718       };
31719     } catch (...) {
31720       {
31721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31722       };
31723     }
31724   }
31725 }
31726
31727
31728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
31729   void * jresult ;
31730   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31731   Dali::Vector2 result;
31732
31733   arg1 = (Dali::Actor *)jarg1;
31734   {
31735     try {
31736       result = (arg1)->GetMaximumSize();
31737     } catch (std::out_of_range& e) {
31738       {
31739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31740       };
31741     } catch (std::exception& e) {
31742       {
31743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31744       };
31745     } catch (...) {
31746       {
31747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31748       };
31749     }
31750   }
31751   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31752   return jresult;
31753 }
31754
31755
31756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
31757   int jresult ;
31758   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31759   int result;
31760
31761   arg1 = (Dali::Actor *)jarg1;
31762   {
31763     try {
31764       result = (int)(arg1)->GetHierarchyDepth();
31765     } catch (std::out_of_range& e) {
31766       {
31767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31768       };
31769     } catch (std::exception& e) {
31770       {
31771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31772       };
31773     } catch (...) {
31774       {
31775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31776       };
31777     }
31778   }
31779   jresult = result;
31780   return jresult;
31781 }
31782
31783
31784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
31785   unsigned int jresult ;
31786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31787   Dali::Renderer *arg2 = 0 ;
31788   unsigned int result;
31789
31790   arg1 = (Dali::Actor *)jarg1;
31791   arg2 = (Dali::Renderer *)jarg2;
31792   if (!arg2) {
31793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31794     return 0;
31795   }
31796   {
31797     try {
31798       result = (unsigned int)(arg1)->AddRenderer(*arg2);
31799     } catch (std::out_of_range& e) {
31800       {
31801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31802       };
31803     } catch (std::exception& e) {
31804       {
31805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31806       };
31807     } catch (...) {
31808       {
31809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31810       };
31811     }
31812   }
31813   jresult = result;
31814   return jresult;
31815 }
31816
31817
31818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
31819   unsigned int jresult ;
31820   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31821   unsigned int result;
31822
31823   arg1 = (Dali::Actor *)jarg1;
31824   {
31825     try {
31826       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
31827     } catch (std::out_of_range& e) {
31828       {
31829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31830       };
31831     } catch (std::exception& e) {
31832       {
31833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31834       };
31835     } catch (...) {
31836       {
31837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31838       };
31839     }
31840   }
31841   jresult = result;
31842   return jresult;
31843 }
31844
31845
31846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
31847   void * jresult ;
31848   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31849   unsigned int arg2 ;
31850   Dali::Renderer result;
31851
31852   arg1 = (Dali::Actor *)jarg1;
31853   arg2 = (unsigned int)jarg2;
31854   {
31855     try {
31856       result = (arg1)->GetRendererAt(arg2);
31857     } catch (std::out_of_range& e) {
31858       {
31859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31860       };
31861     } catch (std::exception& e) {
31862       {
31863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31864       };
31865     } catch (...) {
31866       {
31867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31868       };
31869     }
31870   }
31871   jresult = new Dali::Renderer((const Dali::Renderer &)result);
31872   return jresult;
31873 }
31874
31875
31876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
31877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31878   Dali::Renderer *arg2 = 0 ;
31879
31880   arg1 = (Dali::Actor *)jarg1;
31881   arg2 = (Dali::Renderer *)jarg2;
31882   if (!arg2) {
31883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31884     return ;
31885   }
31886   {
31887     try {
31888       (arg1)->RemoveRenderer(*arg2);
31889     } catch (std::out_of_range& e) {
31890       {
31891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31892       };
31893     } catch (std::exception& e) {
31894       {
31895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31896       };
31897     } catch (...) {
31898       {
31899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31900       };
31901     }
31902   }
31903 }
31904
31905
31906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
31907   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31908   unsigned int arg2 ;
31909
31910   arg1 = (Dali::Actor *)jarg1;
31911   arg2 = (unsigned int)jarg2;
31912   {
31913     try {
31914       (arg1)->RemoveRenderer(arg2);
31915     } catch (std::out_of_range& e) {
31916       {
31917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31918       };
31919     } catch (std::exception& e) {
31920       {
31921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31922       };
31923     } catch (...) {
31924       {
31925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31926       };
31927     }
31928   }
31929 }
31930
31931
31932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
31933   void * jresult ;
31934   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31935   Dali::Actor::TouchSignalType *result = 0 ;
31936
31937   arg1 = (Dali::Actor *)jarg1;
31938   {
31939     try {
31940       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
31941     } catch (std::out_of_range& e) {
31942       {
31943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31944       };
31945     } catch (std::exception& e) {
31946       {
31947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31948       };
31949     } catch (...) {
31950       {
31951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31952       };
31953     }
31954   }
31955   jresult = (void *)result;
31956   return jresult;
31957 }
31958
31959
31960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
31961   void * jresult ;
31962   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31963   Dali::Actor::TouchDataSignalType *result = 0 ;
31964
31965   arg1 = (Dali::Actor *)jarg1;
31966   {
31967     try {
31968       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
31969     } catch (std::out_of_range& e) {
31970       {
31971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31972       };
31973     } catch (std::exception& e) {
31974       {
31975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31976       };
31977     } catch (...) {
31978       {
31979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31980       };
31981     }
31982   }
31983   jresult = (void *)result;
31984   return jresult;
31985 }
31986
31987
31988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
31989   void * jresult ;
31990   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31991   Dali::Actor::HoverSignalType *result = 0 ;
31992
31993   arg1 = (Dali::Actor *)jarg1;
31994   {
31995     try {
31996       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
31997     } catch (std::out_of_range& e) {
31998       {
31999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32000       };
32001     } catch (std::exception& e) {
32002       {
32003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32004       };
32005     } catch (...) {
32006       {
32007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32008       };
32009     }
32010   }
32011   jresult = (void *)result;
32012   return jresult;
32013 }
32014
32015
32016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32017   void * jresult ;
32018   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32019   Dali::Actor::WheelEventSignalType *result = 0 ;
32020
32021   arg1 = (Dali::Actor *)jarg1;
32022   {
32023     try {
32024       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32025     } catch (std::out_of_range& e) {
32026       {
32027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32028       };
32029     } catch (std::exception& e) {
32030       {
32031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32032       };
32033     } catch (...) {
32034       {
32035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32036       };
32037     }
32038   }
32039   jresult = (void *)result;
32040   return jresult;
32041 }
32042
32043
32044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32045   void * jresult ;
32046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32047   Dali::Actor::OnStageSignalType *result = 0 ;
32048
32049   arg1 = (Dali::Actor *)jarg1;
32050   {
32051     try {
32052       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32053     } catch (std::out_of_range& e) {
32054       {
32055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32056       };
32057     } catch (std::exception& e) {
32058       {
32059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32060       };
32061     } catch (...) {
32062       {
32063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32064       };
32065     }
32066   }
32067   jresult = (void *)result;
32068   return jresult;
32069 }
32070
32071
32072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32073   void * jresult ;
32074   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32075   Dali::Actor::OffStageSignalType *result = 0 ;
32076
32077   arg1 = (Dali::Actor *)jarg1;
32078   {
32079     try {
32080       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32081     } catch (std::out_of_range& e) {
32082       {
32083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32084       };
32085     } catch (std::exception& e) {
32086       {
32087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32088       };
32089     } catch (...) {
32090       {
32091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32092       };
32093     }
32094   }
32095   jresult = (void *)result;
32096   return jresult;
32097 }
32098
32099
32100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32101   void * jresult ;
32102   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32103   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32104
32105   arg1 = (Dali::Actor *)jarg1;
32106   {
32107     try {
32108       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32109     } catch (std::out_of_range& e) {
32110       {
32111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32112       };
32113     } catch (std::exception& e) {
32114       {
32115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32116       };
32117     } catch (...) {
32118       {
32119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32120       };
32121     }
32122   }
32123   jresult = (void *)result;
32124   return jresult;
32125 }
32126
32127
32128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32129   Dali::Actor *arg1 = 0 ;
32130
32131   arg1 = (Dali::Actor *)jarg1;
32132   if (!arg1) {
32133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32134     return ;
32135   }
32136   {
32137     try {
32138       Dali::UnparentAndReset(*arg1);
32139     } catch (std::out_of_range& e) {
32140       {
32141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32142       };
32143     } catch (std::exception& e) {
32144       {
32145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32146       };
32147     } catch (...) {
32148       {
32149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32150       };
32151     }
32152   }
32153 }
32154
32155
32156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32157   Dali::Actor arg1 ;
32158   Dali::Actor *argp1 ;
32159
32160   argp1 = (Dali::Actor *)jarg1;
32161   if (!argp1) {
32162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32163     return ;
32164   }
32165   arg1 = *argp1;
32166   {
32167     try {
32168       Dali::DevelActor::Raise(arg1);
32169     } catch (std::out_of_range& e) {
32170       {
32171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32172       };
32173     } catch (std::exception& e) {
32174       {
32175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32176       };
32177     } catch (...) {
32178       {
32179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32180       };
32181     }
32182   }
32183 }
32184
32185
32186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32187   Dali::Actor arg1 ;
32188   Dali::Actor *argp1 ;
32189
32190   argp1 = (Dali::Actor *)jarg1;
32191   if (!argp1) {
32192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32193     return ;
32194   }
32195   arg1 = *argp1;
32196   {
32197     try {
32198       Dali::DevelActor::Lower(arg1);
32199     } catch (std::out_of_range& e) {
32200       {
32201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32202       };
32203     } catch (std::exception& e) {
32204       {
32205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32206       };
32207     } catch (...) {
32208       {
32209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32210       };
32211     }
32212   }
32213 }
32214
32215
32216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32217   Dali::Actor arg1 ;
32218   Dali::Actor *argp1 ;
32219
32220   argp1 = (Dali::Actor *)jarg1;
32221   if (!argp1) {
32222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32223     return ;
32224   }
32225   arg1 = *argp1;
32226   {
32227     try {
32228       Dali::DevelActor::RaiseToTop(arg1);
32229     } catch (std::out_of_range& e) {
32230       {
32231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32232       };
32233     } catch (std::exception& e) {
32234       {
32235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32236       };
32237     } catch (...) {
32238       {
32239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32240       };
32241     }
32242   }
32243 }
32244
32245
32246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32247   Dali::Actor arg1 ;
32248   Dali::Actor *argp1 ;
32249
32250   argp1 = (Dali::Actor *)jarg1;
32251   if (!argp1) {
32252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32253     return ;
32254   }
32255   arg1 = *argp1;
32256   {
32257     try {
32258       Dali::DevelActor::LowerToBottom(arg1);
32259     } catch (std::out_of_range& e) {
32260       {
32261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32262       };
32263     } catch (std::exception& e) {
32264       {
32265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32266       };
32267     } catch (...) {
32268       {
32269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32270       };
32271     }
32272   }
32273 }
32274
32275
32276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32277   Dali::Actor arg1 ;
32278   Dali::Actor arg2 ;
32279   Dali::Actor *argp1 ;
32280   Dali::Actor *argp2 ;
32281
32282   argp1 = (Dali::Actor *)jarg1;
32283   if (!argp1) {
32284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32285     return ;
32286   }
32287   arg1 = *argp1;
32288   argp2 = (Dali::Actor *)jarg2;
32289   if (!argp2) {
32290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32291     return ;
32292   }
32293   arg2 = *argp2;
32294   {
32295     try {
32296       Dali::DevelActor::RaiseAbove(arg1,arg2);
32297     } catch (std::out_of_range& e) {
32298       {
32299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32300       };
32301     } catch (std::exception& e) {
32302       {
32303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32304       };
32305     } catch (...) {
32306       {
32307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32308       };
32309     }
32310   }
32311 }
32312
32313
32314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32315   Dali::Actor arg1 ;
32316   Dali::Actor arg2 ;
32317   Dali::Actor *argp1 ;
32318   Dali::Actor *argp2 ;
32319
32320   argp1 = (Dali::Actor *)jarg1;
32321   if (!argp1) {
32322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32323     return ;
32324   }
32325   arg1 = *argp1;
32326   argp2 = (Dali::Actor *)jarg2;
32327   if (!argp2) {
32328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32329     return ;
32330   }
32331   arg2 = *argp2;
32332   {
32333     try {
32334       Dali::DevelActor::LowerBelow(arg1,arg2);
32335     } catch (std::out_of_range& e) {
32336       {
32337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32338       };
32339     } catch (std::exception& e) {
32340       {
32341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32342       };
32343     } catch (...) {
32344       {
32345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32346       };
32347     }
32348   }
32349 }
32350
32351
32352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32353   int jresult ;
32354   int result;
32355
32356   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32357   jresult = (int)result;
32358   return jresult;
32359 }
32360
32361
32362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32363   int jresult ;
32364   int result;
32365
32366   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32367   jresult = (int)result;
32368   return jresult;
32369 }
32370
32371
32372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32373   int jresult ;
32374   int result;
32375
32376   result = (int)Dali::Layer::Property::BEHAVIOR;
32377   jresult = (int)result;
32378   return jresult;
32379 }
32380
32381
32382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32383   void * jresult ;
32384   Dali::Layer::Property *result = 0 ;
32385
32386   {
32387     try {
32388       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32389     } catch (std::out_of_range& e) {
32390       {
32391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32392       };
32393     } catch (std::exception& e) {
32394       {
32395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32396       };
32397     } catch (...) {
32398       {
32399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32400       };
32401     }
32402   }
32403   jresult = (void *)result;
32404   return jresult;
32405 }
32406
32407
32408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32409   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32410
32411   arg1 = (Dali::Layer::Property *)jarg1;
32412   {
32413     try {
32414       delete arg1;
32415     } catch (std::out_of_range& e) {
32416       {
32417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32418       };
32419     } catch (std::exception& e) {
32420       {
32421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32422       };
32423     } catch (...) {
32424       {
32425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32426       };
32427     }
32428   }
32429 }
32430
32431
32432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32433   void * jresult ;
32434   Dali::Layer *result = 0 ;
32435
32436   {
32437     try {
32438       result = (Dali::Layer *)new Dali::Layer();
32439     } catch (std::out_of_range& e) {
32440       {
32441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32442       };
32443     } catch (std::exception& e) {
32444       {
32445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32446       };
32447     } catch (...) {
32448       {
32449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32450       };
32451     }
32452   }
32453   jresult = (void *)result;
32454   return jresult;
32455 }
32456
32457
32458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32459   void * jresult ;
32460   Dali::Layer result;
32461
32462   {
32463     try {
32464       result = Dali::Layer::New();
32465     } catch (std::out_of_range& e) {
32466       {
32467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32468       };
32469     } catch (std::exception& e) {
32470       {
32471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32472       };
32473     } catch (...) {
32474       {
32475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32476       };
32477     }
32478   }
32479   jresult = new Dali::Layer((const Dali::Layer &)result);
32480   return jresult;
32481 }
32482
32483
32484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32485   void * jresult ;
32486   Dali::BaseHandle arg1 ;
32487   Dali::BaseHandle *argp1 ;
32488   Dali::Layer result;
32489
32490   argp1 = (Dali::BaseHandle *)jarg1;
32491   if (!argp1) {
32492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32493     return 0;
32494   }
32495   arg1 = *argp1;
32496   {
32497     try {
32498       result = Dali::Layer::DownCast(arg1);
32499     } catch (std::out_of_range& e) {
32500       {
32501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32502       };
32503     } catch (std::exception& e) {
32504       {
32505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32506       };
32507     } catch (...) {
32508       {
32509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32510       };
32511     }
32512   }
32513   jresult = new Dali::Layer((const Dali::Layer &)result);
32514   return jresult;
32515 }
32516
32517
32518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32519   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32520
32521   arg1 = (Dali::Layer *)jarg1;
32522   {
32523     try {
32524       delete arg1;
32525     } catch (std::out_of_range& e) {
32526       {
32527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32528       };
32529     } catch (std::exception& e) {
32530       {
32531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32532       };
32533     } catch (...) {
32534       {
32535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32536       };
32537     }
32538   }
32539 }
32540
32541
32542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32543   void * jresult ;
32544   Dali::Layer *arg1 = 0 ;
32545   Dali::Layer *result = 0 ;
32546
32547   arg1 = (Dali::Layer *)jarg1;
32548   if (!arg1) {
32549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32550     return 0;
32551   }
32552   {
32553     try {
32554       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32555     } catch (std::out_of_range& e) {
32556       {
32557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32558       };
32559     } catch (std::exception& e) {
32560       {
32561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32562       };
32563     } catch (...) {
32564       {
32565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32566       };
32567     }
32568   }
32569   jresult = (void *)result;
32570   return jresult;
32571 }
32572
32573
32574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32575   void * jresult ;
32576   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32577   Dali::Layer *arg2 = 0 ;
32578   Dali::Layer *result = 0 ;
32579
32580   arg1 = (Dali::Layer *)jarg1;
32581   arg2 = (Dali::Layer *)jarg2;
32582   if (!arg2) {
32583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32584     return 0;
32585   }
32586   {
32587     try {
32588       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32589     } catch (std::out_of_range& e) {
32590       {
32591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32592       };
32593     } catch (std::exception& e) {
32594       {
32595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32596       };
32597     } catch (...) {
32598       {
32599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32600       };
32601     }
32602   }
32603   jresult = (void *)result;
32604   return jresult;
32605 }
32606
32607
32608 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32609   unsigned int jresult ;
32610   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32611   unsigned int result;
32612
32613   arg1 = (Dali::Layer *)jarg1;
32614   {
32615     try {
32616       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32617     } catch (std::out_of_range& e) {
32618       {
32619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32620       };
32621     } catch (std::exception& e) {
32622       {
32623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32624       };
32625     } catch (...) {
32626       {
32627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32628       };
32629     }
32630   }
32631   jresult = result;
32632   return jresult;
32633 }
32634
32635
32636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32637   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32638
32639   arg1 = (Dali::Layer *)jarg1;
32640   {
32641     try {
32642       (arg1)->Raise();
32643     } catch (std::out_of_range& e) {
32644       {
32645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32646       };
32647     } catch (std::exception& e) {
32648       {
32649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32650       };
32651     } catch (...) {
32652       {
32653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32654       };
32655     }
32656   }
32657 }
32658
32659
32660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32661   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32662
32663   arg1 = (Dali::Layer *)jarg1;
32664   {
32665     try {
32666       (arg1)->Lower();
32667     } catch (std::out_of_range& e) {
32668       {
32669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32670       };
32671     } catch (std::exception& e) {
32672       {
32673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32674       };
32675     } catch (...) {
32676       {
32677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32678       };
32679     }
32680   }
32681 }
32682
32683
32684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
32685   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32686   Dali::Layer arg2 ;
32687   Dali::Layer *argp2 ;
32688
32689   arg1 = (Dali::Layer *)jarg1;
32690   argp2 = (Dali::Layer *)jarg2;
32691   if (!argp2) {
32692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32693     return ;
32694   }
32695   arg2 = *argp2;
32696   {
32697     try {
32698       (arg1)->RaiseAbove(arg2);
32699     } catch (std::out_of_range& e) {
32700       {
32701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32702       };
32703     } catch (std::exception& e) {
32704       {
32705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32706       };
32707     } catch (...) {
32708       {
32709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32710       };
32711     }
32712   }
32713 }
32714
32715
32716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32717   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32718   Dali::Layer arg2 ;
32719   Dali::Layer *argp2 ;
32720
32721   arg1 = (Dali::Layer *)jarg1;
32722   argp2 = (Dali::Layer *)jarg2;
32723   if (!argp2) {
32724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32725     return ;
32726   }
32727   arg2 = *argp2;
32728   {
32729     try {
32730       (arg1)->LowerBelow(arg2);
32731     } catch (std::out_of_range& e) {
32732       {
32733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32734       };
32735     } catch (std::exception& e) {
32736       {
32737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32738       };
32739     } catch (...) {
32740       {
32741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32742       };
32743     }
32744   }
32745 }
32746
32747
32748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32749   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32750
32751   arg1 = (Dali::Layer *)jarg1;
32752   {
32753     try {
32754       (arg1)->RaiseToTop();
32755     } catch (std::out_of_range& e) {
32756       {
32757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32758       };
32759     } catch (std::exception& e) {
32760       {
32761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32762       };
32763     } catch (...) {
32764       {
32765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32766       };
32767     }
32768   }
32769 }
32770
32771
32772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32773   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32774
32775   arg1 = (Dali::Layer *)jarg1;
32776   {
32777     try {
32778       (arg1)->LowerToBottom();
32779     } catch (std::out_of_range& e) {
32780       {
32781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32782       };
32783     } catch (std::exception& e) {
32784       {
32785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32786       };
32787     } catch (...) {
32788       {
32789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32790       };
32791     }
32792   }
32793 }
32794
32795
32796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32797   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32798   Dali::Layer arg2 ;
32799   Dali::Layer *argp2 ;
32800
32801   arg1 = (Dali::Layer *)jarg1;
32802   argp2 = (Dali::Layer *)jarg2;
32803   if (!argp2) {
32804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32805     return ;
32806   }
32807   arg2 = *argp2;
32808   {
32809     try {
32810       (arg1)->MoveAbove(arg2);
32811     } catch (std::out_of_range& e) {
32812       {
32813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32814       };
32815     } catch (std::exception& e) {
32816       {
32817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32818       };
32819     } catch (...) {
32820       {
32821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32822       };
32823     }
32824   }
32825 }
32826
32827
32828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
32829   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32830   Dali::Layer arg2 ;
32831   Dali::Layer *argp2 ;
32832
32833   arg1 = (Dali::Layer *)jarg1;
32834   argp2 = (Dali::Layer *)jarg2;
32835   if (!argp2) {
32836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32837     return ;
32838   }
32839   arg2 = *argp2;
32840   {
32841     try {
32842       (arg1)->MoveBelow(arg2);
32843     } catch (std::out_of_range& e) {
32844       {
32845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32846       };
32847     } catch (std::exception& e) {
32848       {
32849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32850       };
32851     } catch (...) {
32852       {
32853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32854       };
32855     }
32856   }
32857 }
32858
32859
32860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
32861   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32862   Dali::Layer::Behavior arg2 ;
32863
32864   arg1 = (Dali::Layer *)jarg1;
32865   arg2 = (Dali::Layer::Behavior)jarg2;
32866   {
32867     try {
32868       (arg1)->SetBehavior(arg2);
32869     } catch (std::out_of_range& e) {
32870       {
32871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32872       };
32873     } catch (std::exception& e) {
32874       {
32875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32876       };
32877     } catch (...) {
32878       {
32879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32880       };
32881     }
32882   }
32883 }
32884
32885
32886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
32887   int jresult ;
32888   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32889   Dali::Layer::Behavior result;
32890
32891   arg1 = (Dali::Layer *)jarg1;
32892   {
32893     try {
32894       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
32895     } catch (std::out_of_range& e) {
32896       {
32897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32898       };
32899     } catch (std::exception& e) {
32900       {
32901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32902       };
32903     } catch (...) {
32904       {
32905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32906       };
32907     }
32908   }
32909   jresult = (int)result;
32910   return jresult;
32911 }
32912
32913
32914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
32915   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32916   bool arg2 ;
32917
32918   arg1 = (Dali::Layer *)jarg1;
32919   arg2 = jarg2 ? true : false;
32920   {
32921     try {
32922       (arg1)->SetClipping(arg2);
32923     } catch (std::out_of_range& e) {
32924       {
32925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32926       };
32927     } catch (std::exception& e) {
32928       {
32929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32930       };
32931     } catch (...) {
32932       {
32933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32934       };
32935     }
32936   }
32937 }
32938
32939
32940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
32941   unsigned int jresult ;
32942   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32943   bool result;
32944
32945   arg1 = (Dali::Layer *)jarg1;
32946   {
32947     try {
32948       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
32949     } catch (std::out_of_range& e) {
32950       {
32951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32952       };
32953     } catch (std::exception& e) {
32954       {
32955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32956       };
32957     } catch (...) {
32958       {
32959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32960       };
32961     }
32962   }
32963   jresult = result;
32964   return jresult;
32965 }
32966
32967
32968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
32969   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32970   int arg2 ;
32971   int arg3 ;
32972   int arg4 ;
32973   int arg5 ;
32974
32975   arg1 = (Dali::Layer *)jarg1;
32976   arg2 = (int)jarg2;
32977   arg3 = (int)jarg3;
32978   arg4 = (int)jarg4;
32979   arg5 = (int)jarg5;
32980   {
32981     try {
32982       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
32983     } catch (std::out_of_range& e) {
32984       {
32985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32986       };
32987     } catch (std::exception& e) {
32988       {
32989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32990       };
32991     } catch (...) {
32992       {
32993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32994       };
32995     }
32996   }
32997 }
32998
32999
33000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33001   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33002   Dali::ClippingBox arg2 ;
33003   Dali::ClippingBox *argp2 ;
33004
33005   arg1 = (Dali::Layer *)jarg1;
33006   argp2 = (Dali::ClippingBox *)jarg2;
33007   if (!argp2) {
33008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33009     return ;
33010   }
33011   arg2 = *argp2;
33012   {
33013     try {
33014       (arg1)->SetClippingBox(arg2);
33015     } catch (std::out_of_range& e) {
33016       {
33017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33018       };
33019     } catch (std::exception& e) {
33020       {
33021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33022       };
33023     } catch (...) {
33024       {
33025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33026       };
33027     }
33028   }
33029 }
33030
33031
33032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33033   void * jresult ;
33034   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33035   Dali::ClippingBox result;
33036
33037   arg1 = (Dali::Layer *)jarg1;
33038   {
33039     try {
33040       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33041     } catch (std::out_of_range& e) {
33042       {
33043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33044       };
33045     } catch (std::exception& e) {
33046       {
33047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33048       };
33049     } catch (...) {
33050       {
33051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33052       };
33053     }
33054   }
33055   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33056   return jresult;
33057 }
33058
33059
33060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33061   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33062   bool arg2 ;
33063
33064   arg1 = (Dali::Layer *)jarg1;
33065   arg2 = jarg2 ? true : false;
33066   {
33067     try {
33068       (arg1)->SetDepthTestDisabled(arg2);
33069     } catch (std::out_of_range& e) {
33070       {
33071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33072       };
33073     } catch (std::exception& e) {
33074       {
33075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33076       };
33077     } catch (...) {
33078       {
33079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33080       };
33081     }
33082   }
33083 }
33084
33085
33086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33087   unsigned int jresult ;
33088   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33089   bool result;
33090
33091   arg1 = (Dali::Layer *)jarg1;
33092   {
33093     try {
33094       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33095     } catch (std::out_of_range& e) {
33096       {
33097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33098       };
33099     } catch (std::exception& e) {
33100       {
33101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33102       };
33103     } catch (...) {
33104       {
33105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33106       };
33107     }
33108   }
33109   jresult = result;
33110   return jresult;
33111 }
33112
33113
33114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33115   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33116   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33117
33118   arg1 = (Dali::Layer *)jarg1;
33119   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33120   {
33121     try {
33122       (arg1)->SetSortFunction(arg2);
33123     } catch (std::out_of_range& e) {
33124       {
33125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33126       };
33127     } catch (std::exception& e) {
33128       {
33129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33130       };
33131     } catch (...) {
33132       {
33133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33134       };
33135     }
33136   }
33137 }
33138
33139
33140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33141   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33142   bool arg2 ;
33143
33144   arg1 = (Dali::Layer *)jarg1;
33145   arg2 = jarg2 ? true : false;
33146   {
33147     try {
33148       (arg1)->SetTouchConsumed(arg2);
33149     } catch (std::out_of_range& e) {
33150       {
33151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33152       };
33153     } catch (std::exception& e) {
33154       {
33155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33156       };
33157     } catch (...) {
33158       {
33159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33160       };
33161     }
33162   }
33163 }
33164
33165
33166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33167   unsigned int jresult ;
33168   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33169   bool result;
33170
33171   arg1 = (Dali::Layer *)jarg1;
33172   {
33173     try {
33174       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33175     } catch (std::out_of_range& e) {
33176       {
33177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33178       };
33179     } catch (std::exception& e) {
33180       {
33181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33182       };
33183     } catch (...) {
33184       {
33185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33186       };
33187     }
33188   }
33189   jresult = result;
33190   return jresult;
33191 }
33192
33193
33194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33195   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33196   bool arg2 ;
33197
33198   arg1 = (Dali::Layer *)jarg1;
33199   arg2 = jarg2 ? true : false;
33200   {
33201     try {
33202       (arg1)->SetHoverConsumed(arg2);
33203     } catch (std::out_of_range& e) {
33204       {
33205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33206       };
33207     } catch (std::exception& e) {
33208       {
33209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33210       };
33211     } catch (...) {
33212       {
33213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33214       };
33215     }
33216   }
33217 }
33218
33219
33220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33221   unsigned int jresult ;
33222   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33223   bool result;
33224
33225   arg1 = (Dali::Layer *)jarg1;
33226   {
33227     try {
33228       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33229     } catch (std::out_of_range& e) {
33230       {
33231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33232       };
33233     } catch (std::exception& e) {
33234       {
33235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33236       };
33237     } catch (...) {
33238       {
33239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33240       };
33241     }
33242   }
33243   jresult = result;
33244   return jresult;
33245 }
33246
33247
33248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33249   void * jresult ;
33250   Dali::Vector4 *result = 0 ;
33251
33252   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33253   jresult = (void *)result;
33254   return jresult;
33255 }
33256
33257
33258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33259   void * jresult ;
33260   Dali::Vector4 *result = 0 ;
33261
33262   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33263   jresult = (void *)result;
33264   return jresult;
33265 }
33266
33267
33268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33269   void * jresult ;
33270   Dali::Stage *result = 0 ;
33271
33272   {
33273     try {
33274       result = (Dali::Stage *)new Dali::Stage();
33275     } catch (std::out_of_range& e) {
33276       {
33277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33278       };
33279     } catch (std::exception& e) {
33280       {
33281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33282       };
33283     } catch (...) {
33284       {
33285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33286       };
33287     }
33288   }
33289   jresult = (void *)result;
33290   return jresult;
33291 }
33292
33293
33294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33295   void * jresult ;
33296   Dali::Stage result;
33297
33298   {
33299     try {
33300       result = Dali::Stage::GetCurrent();
33301     } catch (std::out_of_range& e) {
33302       {
33303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33304       };
33305     } catch (std::exception& e) {
33306       {
33307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33308       };
33309     } catch (...) {
33310       {
33311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33312       };
33313     }
33314   }
33315   jresult = new Dali::Stage((const Dali::Stage &)result);
33316   return jresult;
33317 }
33318
33319
33320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33321   unsigned int jresult ;
33322   bool result;
33323
33324   {
33325     try {
33326       result = (bool)Dali::Stage::IsInstalled();
33327     } catch (std::out_of_range& e) {
33328       {
33329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33330       };
33331     } catch (std::exception& e) {
33332       {
33333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33334       };
33335     } catch (...) {
33336       {
33337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33338       };
33339     }
33340   }
33341   jresult = result;
33342   return jresult;
33343 }
33344
33345
33346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33347   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33348
33349   arg1 = (Dali::Stage *)jarg1;
33350   {
33351     try {
33352       delete arg1;
33353     } catch (std::out_of_range& e) {
33354       {
33355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33356       };
33357     } catch (std::exception& e) {
33358       {
33359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33360       };
33361     } catch (...) {
33362       {
33363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33364       };
33365     }
33366   }
33367 }
33368
33369
33370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33371   void * jresult ;
33372   Dali::Stage *arg1 = 0 ;
33373   Dali::Stage *result = 0 ;
33374
33375   arg1 = (Dali::Stage *)jarg1;
33376   if (!arg1) {
33377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33378     return 0;
33379   }
33380   {
33381     try {
33382       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33383     } catch (std::out_of_range& e) {
33384       {
33385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33386       };
33387     } catch (std::exception& e) {
33388       {
33389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33390       };
33391     } catch (...) {
33392       {
33393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33394       };
33395     }
33396   }
33397   jresult = (void *)result;
33398   return jresult;
33399 }
33400
33401
33402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33403   void * jresult ;
33404   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33405   Dali::Stage *arg2 = 0 ;
33406   Dali::Stage *result = 0 ;
33407
33408   arg1 = (Dali::Stage *)jarg1;
33409   arg2 = (Dali::Stage *)jarg2;
33410   if (!arg2) {
33411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33412     return 0;
33413   }
33414   {
33415     try {
33416       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33417     } catch (std::out_of_range& e) {
33418       {
33419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33420       };
33421     } catch (std::exception& e) {
33422       {
33423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33424       };
33425     } catch (...) {
33426       {
33427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33428       };
33429     }
33430   }
33431   jresult = (void *)result;
33432   return jresult;
33433 }
33434
33435
33436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33437   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33438   Dali::Actor *arg2 = 0 ;
33439
33440   arg1 = (Dali::Stage *)jarg1;
33441   arg2 = (Dali::Actor *)jarg2;
33442   if (!arg2) {
33443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33444     return ;
33445   }
33446   {
33447     try {
33448       (arg1)->Add(*arg2);
33449     } catch (std::out_of_range& e) {
33450       {
33451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33452       };
33453     } catch (std::exception& e) {
33454       {
33455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33456       };
33457     } catch (...) {
33458       {
33459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33460       };
33461     }
33462   }
33463 }
33464
33465
33466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33467   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33468   Dali::Actor *arg2 = 0 ;
33469
33470   arg1 = (Dali::Stage *)jarg1;
33471   arg2 = (Dali::Actor *)jarg2;
33472   if (!arg2) {
33473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33474     return ;
33475   }
33476   {
33477     try {
33478       (arg1)->Remove(*arg2);
33479     } catch (std::out_of_range& e) {
33480       {
33481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33482       };
33483     } catch (std::exception& e) {
33484       {
33485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33486       };
33487     } catch (...) {
33488       {
33489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33490       };
33491     }
33492   }
33493 }
33494
33495
33496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33497   void * jresult ;
33498   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33499   Dali::Vector2 result;
33500
33501   arg1 = (Dali::Stage *)jarg1;
33502   {
33503     try {
33504       result = ((Dali::Stage const *)arg1)->GetSize();
33505     } catch (std::out_of_range& e) {
33506       {
33507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33508       };
33509     } catch (std::exception& e) {
33510       {
33511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33512       };
33513     } catch (...) {
33514       {
33515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33516       };
33517     }
33518   }
33519   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33520   return jresult;
33521 }
33522
33523
33524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33525   void * jresult ;
33526   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33527   Dali::RenderTaskList result;
33528
33529   arg1 = (Dali::Stage *)jarg1;
33530   {
33531     try {
33532       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33533     } catch (std::out_of_range& e) {
33534       {
33535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33536       };
33537     } catch (std::exception& e) {
33538       {
33539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33540       };
33541     } catch (...) {
33542       {
33543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33544       };
33545     }
33546   }
33547   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33548   return jresult;
33549 }
33550
33551
33552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33553   unsigned int jresult ;
33554   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33555   unsigned int result;
33556
33557   arg1 = (Dali::Stage *)jarg1;
33558   {
33559     try {
33560       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33561     } catch (std::out_of_range& e) {
33562       {
33563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33564       };
33565     } catch (std::exception& e) {
33566       {
33567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33568       };
33569     } catch (...) {
33570       {
33571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33572       };
33573     }
33574   }
33575   jresult = result;
33576   return jresult;
33577 }
33578
33579
33580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33581   void * jresult ;
33582   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33583   unsigned int arg2 ;
33584   Dali::Layer result;
33585
33586   arg1 = (Dali::Stage *)jarg1;
33587   arg2 = (unsigned int)jarg2;
33588   {
33589     try {
33590       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33591     } catch (std::out_of_range& e) {
33592       {
33593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33594       };
33595     } catch (std::exception& e) {
33596       {
33597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33598       };
33599     } catch (...) {
33600       {
33601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33602       };
33603     }
33604   }
33605   jresult = new Dali::Layer((const Dali::Layer &)result);
33606   return jresult;
33607 }
33608
33609
33610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33611   void * jresult ;
33612   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33613   Dali::Layer result;
33614
33615   arg1 = (Dali::Stage *)jarg1;
33616   {
33617     try {
33618       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33619     } catch (std::out_of_range& e) {
33620       {
33621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33622       };
33623     } catch (std::exception& e) {
33624       {
33625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33626       };
33627     } catch (...) {
33628       {
33629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33630       };
33631     }
33632   }
33633   jresult = new Dali::Layer((const Dali::Layer &)result);
33634   return jresult;
33635 }
33636
33637
33638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33639   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33640   Dali::Vector4 arg2 ;
33641   Dali::Vector4 *argp2 ;
33642
33643   arg1 = (Dali::Stage *)jarg1;
33644   argp2 = (Dali::Vector4 *)jarg2;
33645   if (!argp2) {
33646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33647     return ;
33648   }
33649   arg2 = *argp2;
33650   {
33651     try {
33652       (arg1)->SetBackgroundColor(arg2);
33653     } catch (std::out_of_range& e) {
33654       {
33655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33656       };
33657     } catch (std::exception& e) {
33658       {
33659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33660       };
33661     } catch (...) {
33662       {
33663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33664       };
33665     }
33666   }
33667 }
33668
33669
33670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33671   void * jresult ;
33672   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33673   Dali::Vector4 result;
33674
33675   arg1 = (Dali::Stage *)jarg1;
33676   {
33677     try {
33678       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33679     } catch (std::out_of_range& e) {
33680       {
33681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33682       };
33683     } catch (std::exception& e) {
33684       {
33685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33686       };
33687     } catch (...) {
33688       {
33689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33690       };
33691     }
33692   }
33693   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33694   return jresult;
33695 }
33696
33697
33698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33699   void * jresult ;
33700   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33701   Dali::Vector2 result;
33702
33703   arg1 = (Dali::Stage *)jarg1;
33704   {
33705     try {
33706       result = ((Dali::Stage const *)arg1)->GetDpi();
33707     } catch (std::out_of_range& e) {
33708       {
33709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33710       };
33711     } catch (std::exception& e) {
33712       {
33713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33714       };
33715     } catch (...) {
33716       {
33717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33718       };
33719     }
33720   }
33721   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33722   return jresult;
33723 }
33724
33725
33726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33727   void * jresult ;
33728   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33729   Dali::ObjectRegistry result;
33730
33731   arg1 = (Dali::Stage *)jarg1;
33732   {
33733     try {
33734       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33735     } catch (std::out_of_range& e) {
33736       {
33737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33738       };
33739     } catch (std::exception& e) {
33740       {
33741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33742       };
33743     } catch (...) {
33744       {
33745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33746       };
33747     }
33748   }
33749   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33750   return jresult;
33751 }
33752
33753
33754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33755   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33756   float arg2 ;
33757
33758   arg1 = (Dali::Stage *)jarg1;
33759   arg2 = (float)jarg2;
33760   {
33761     try {
33762       (arg1)->KeepRendering(arg2);
33763     } catch (std::out_of_range& e) {
33764       {
33765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33766       };
33767     } catch (std::exception& e) {
33768       {
33769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33770       };
33771     } catch (...) {
33772       {
33773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33774       };
33775     }
33776   }
33777 }
33778
33779
33780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33781   void * jresult ;
33782   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33783   Dali::Stage::KeyEventSignalType *result = 0 ;
33784
33785   arg1 = (Dali::Stage *)jarg1;
33786   {
33787     try {
33788       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33789     } catch (std::out_of_range& e) {
33790       {
33791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33792       };
33793     } catch (std::exception& e) {
33794       {
33795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33796       };
33797     } catch (...) {
33798       {
33799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33800       };
33801     }
33802   }
33803   jresult = (void *)result;
33804   return jresult;
33805 }
33806
33807
33808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33809   void * jresult ;
33810   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33811   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33812
33813   arg1 = (Dali::Stage *)jarg1;
33814   {
33815     try {
33816       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33817     } catch (std::out_of_range& e) {
33818       {
33819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33820       };
33821     } catch (std::exception& e) {
33822       {
33823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33824       };
33825     } catch (...) {
33826       {
33827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33828       };
33829     }
33830   }
33831   jresult = (void *)result;
33832   return jresult;
33833 }
33834
33835
33836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
33837   void * jresult ;
33838   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33839   Dali::Stage::TouchSignalType *result = 0 ;
33840
33841   arg1 = (Dali::Stage *)jarg1;
33842   {
33843     try {
33844       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
33845     } catch (std::out_of_range& e) {
33846       {
33847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33848       };
33849     } catch (std::exception& e) {
33850       {
33851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33852       };
33853     } catch (...) {
33854       {
33855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33856       };
33857     }
33858   }
33859   jresult = (void *)result;
33860   return jresult;
33861 }
33862
33863
33864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
33865   void * jresult ;
33866   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33867   Dali::Stage::WheelEventSignalType *result = 0 ;
33868
33869   arg1 = (Dali::Stage *)jarg1;
33870   {
33871     try {
33872       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
33873     } catch (std::out_of_range& e) {
33874       {
33875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33876       };
33877     } catch (std::exception& e) {
33878       {
33879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33880       };
33881     } catch (...) {
33882       {
33883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33884       };
33885     }
33886   }
33887   jresult = (void *)result;
33888   return jresult;
33889 }
33890
33891
33892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
33893   void * jresult ;
33894   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33895   Dali::Stage::ContextStatusSignal *result = 0 ;
33896
33897   arg1 = (Dali::Stage *)jarg1;
33898   {
33899     try {
33900       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
33901     } catch (std::out_of_range& e) {
33902       {
33903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33904       };
33905     } catch (std::exception& e) {
33906       {
33907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33908       };
33909     } catch (...) {
33910       {
33911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33912       };
33913     }
33914   }
33915   jresult = (void *)result;
33916   return jresult;
33917 }
33918
33919
33920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
33921   void * jresult ;
33922   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33923   Dali::Stage::ContextStatusSignal *result = 0 ;
33924
33925   arg1 = (Dali::Stage *)jarg1;
33926   {
33927     try {
33928       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
33929     } catch (std::out_of_range& e) {
33930       {
33931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33932       };
33933     } catch (std::exception& e) {
33934       {
33935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33936       };
33937     } catch (...) {
33938       {
33939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33940       };
33941     }
33942   }
33943   jresult = (void *)result;
33944   return jresult;
33945 }
33946
33947
33948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
33949   void * jresult ;
33950   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33951   Dali::Stage::SceneCreatedSignalType *result = 0 ;
33952
33953   arg1 = (Dali::Stage *)jarg1;
33954   {
33955     try {
33956       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
33957     } catch (std::out_of_range& e) {
33958       {
33959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33960       };
33961     } catch (std::exception& e) {
33962       {
33963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33964       };
33965     } catch (...) {
33966       {
33967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33968       };
33969     }
33970   }
33971   jresult = (void *)result;
33972   return jresult;
33973 }
33974
33975
33976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
33977   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
33978
33979   arg1 = (Dali::RelayoutContainer *)jarg1;
33980   {
33981     try {
33982       delete arg1;
33983     } catch (std::out_of_range& e) {
33984       {
33985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33986       };
33987     } catch (std::exception& e) {
33988       {
33989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33990       };
33991     } catch (...) {
33992       {
33993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33994       };
33995     }
33996   }
33997 }
33998
33999
34000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34001   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34002   Dali::Actor *arg2 = 0 ;
34003   Dali::Vector2 *arg3 = 0 ;
34004
34005   arg1 = (Dali::RelayoutContainer *)jarg1;
34006   arg2 = (Dali::Actor *)jarg2;
34007   if (!arg2) {
34008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34009     return ;
34010   }
34011   arg3 = (Dali::Vector2 *)jarg3;
34012   if (!arg3) {
34013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34014     return ;
34015   }
34016   {
34017     try {
34018       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34019     } catch (std::out_of_range& e) {
34020       {
34021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34022       };
34023     } catch (std::exception& e) {
34024       {
34025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34026       };
34027     } catch (...) {
34028       {
34029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34030       };
34031     }
34032   }
34033 }
34034
34035
34036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34037   void * jresult ;
34038   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34039   Dali::CustomActor result;
34040
34041   arg1 = (Dali::CustomActorImpl *)jarg1;
34042   {
34043     try {
34044       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34045     } catch (std::out_of_range& e) {
34046       {
34047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34048       };
34049     } catch (std::exception& e) {
34050       {
34051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34052       };
34053     } catch (...) {
34054       {
34055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34056       };
34057     }
34058   }
34059   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34060   return jresult;
34061 }
34062
34063
34064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34065   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34066   int arg2 ;
34067
34068   arg1 = (Dali::CustomActorImpl *)jarg1;
34069   arg2 = (int)jarg2;
34070   {
34071     try {
34072       (arg1)->OnStageConnection(arg2);
34073     } catch (std::out_of_range& e) {
34074       {
34075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34076       };
34077     } catch (std::exception& e) {
34078       {
34079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34080       };
34081     } catch (...) {
34082       {
34083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34084       };
34085     }
34086   }
34087 }
34088
34089
34090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34091   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34092
34093   arg1 = (Dali::CustomActorImpl *)jarg1;
34094   {
34095     try {
34096       (arg1)->OnStageDisconnection();
34097     } catch (std::out_of_range& e) {
34098       {
34099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34100       };
34101     } catch (std::exception& e) {
34102       {
34103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34104       };
34105     } catch (...) {
34106       {
34107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34108       };
34109     }
34110   }
34111 }
34112
34113
34114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34115   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34116   Dali::Actor *arg2 = 0 ;
34117
34118   arg1 = (Dali::CustomActorImpl *)jarg1;
34119   arg2 = (Dali::Actor *)jarg2;
34120   if (!arg2) {
34121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34122     return ;
34123   }
34124   {
34125     try {
34126       (arg1)->OnChildAdd(*arg2);
34127     } catch (std::out_of_range& e) {
34128       {
34129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34130       };
34131     } catch (std::exception& e) {
34132       {
34133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34134       };
34135     } catch (...) {
34136       {
34137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34138       };
34139     }
34140   }
34141 }
34142
34143
34144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34145   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34146   Dali::Actor *arg2 = 0 ;
34147
34148   arg1 = (Dali::CustomActorImpl *)jarg1;
34149   arg2 = (Dali::Actor *)jarg2;
34150   if (!arg2) {
34151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34152     return ;
34153   }
34154   {
34155     try {
34156       (arg1)->OnChildRemove(*arg2);
34157     } catch (std::out_of_range& e) {
34158       {
34159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34160       };
34161     } catch (std::exception& e) {
34162       {
34163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34164       };
34165     } catch (...) {
34166       {
34167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34168       };
34169     }
34170   }
34171 }
34172
34173
34174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34175   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34176   Dali::Property::Index arg2 ;
34177   Dali::Property::Value arg3 ;
34178   Dali::Property::Value *argp3 ;
34179
34180   arg1 = (Dali::CustomActorImpl *)jarg1;
34181   arg2 = (Dali::Property::Index)jarg2;
34182   argp3 = (Dali::Property::Value *)jarg3;
34183   if (!argp3) {
34184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34185     return ;
34186   }
34187   arg3 = *argp3;
34188   {
34189     try {
34190       (arg1)->OnPropertySet(arg2,arg3);
34191     } catch (std::out_of_range& e) {
34192       {
34193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34194       };
34195     } catch (std::exception& e) {
34196       {
34197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34198       };
34199     } catch (...) {
34200       {
34201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34202       };
34203     }
34204   }
34205 }
34206
34207
34208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34209   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34210   Dali::Vector3 *arg2 = 0 ;
34211
34212   arg1 = (Dali::CustomActorImpl *)jarg1;
34213   arg2 = (Dali::Vector3 *)jarg2;
34214   if (!arg2) {
34215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34216     return ;
34217   }
34218   {
34219     try {
34220       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34221     } catch (std::out_of_range& e) {
34222       {
34223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34224       };
34225     } catch (std::exception& e) {
34226       {
34227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34228       };
34229     } catch (...) {
34230       {
34231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34232       };
34233     }
34234   }
34235 }
34236
34237
34238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34239   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34240   Dali::Animation *arg2 = 0 ;
34241   Dali::Vector3 *arg3 = 0 ;
34242
34243   arg1 = (Dali::CustomActorImpl *)jarg1;
34244   arg2 = (Dali::Animation *)jarg2;
34245   if (!arg2) {
34246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34247     return ;
34248   }
34249   arg3 = (Dali::Vector3 *)jarg3;
34250   if (!arg3) {
34251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34252     return ;
34253   }
34254   {
34255     try {
34256       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34257     } catch (std::out_of_range& e) {
34258       {
34259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34260       };
34261     } catch (std::exception& e) {
34262       {
34263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34264       };
34265     } catch (...) {
34266       {
34267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34268       };
34269     }
34270   }
34271 }
34272
34273
34274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34275   unsigned int jresult ;
34276   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34277   Dali::TouchEvent *arg2 = 0 ;
34278   bool result;
34279
34280   arg1 = (Dali::CustomActorImpl *)jarg1;
34281   arg2 = (Dali::TouchEvent *)jarg2;
34282   if (!arg2) {
34283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34284     return 0;
34285   }
34286   {
34287     try {
34288       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34289     } catch (std::out_of_range& e) {
34290       {
34291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34292       };
34293     } catch (std::exception& e) {
34294       {
34295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34296       };
34297     } catch (...) {
34298       {
34299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34300       };
34301     }
34302   }
34303   jresult = result;
34304   return jresult;
34305 }
34306
34307
34308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34309   unsigned int jresult ;
34310   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34311   Dali::HoverEvent *arg2 = 0 ;
34312   bool result;
34313
34314   arg1 = (Dali::CustomActorImpl *)jarg1;
34315   arg2 = (Dali::HoverEvent *)jarg2;
34316   if (!arg2) {
34317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34318     return 0;
34319   }
34320   {
34321     try {
34322       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34323     } catch (std::out_of_range& e) {
34324       {
34325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34326       };
34327     } catch (std::exception& e) {
34328       {
34329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34330       };
34331     } catch (...) {
34332       {
34333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34334       };
34335     }
34336   }
34337   jresult = result;
34338   return jresult;
34339 }
34340
34341
34342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34343   unsigned int jresult ;
34344   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34345   Dali::KeyEvent *arg2 = 0 ;
34346   bool result;
34347
34348   arg1 = (Dali::CustomActorImpl *)jarg1;
34349   arg2 = (Dali::KeyEvent *)jarg2;
34350   if (!arg2) {
34351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34352     return 0;
34353   }
34354   {
34355     try {
34356       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34357     } catch (std::out_of_range& e) {
34358       {
34359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34360       };
34361     } catch (std::exception& e) {
34362       {
34363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34364       };
34365     } catch (...) {
34366       {
34367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34368       };
34369     }
34370   }
34371   jresult = result;
34372   return jresult;
34373 }
34374
34375
34376 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34377   unsigned int jresult ;
34378   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34379   Dali::WheelEvent *arg2 = 0 ;
34380   bool result;
34381
34382   arg1 = (Dali::CustomActorImpl *)jarg1;
34383   arg2 = (Dali::WheelEvent *)jarg2;
34384   if (!arg2) {
34385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34386     return 0;
34387   }
34388   {
34389     try {
34390       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34391     } catch (std::out_of_range& e) {
34392       {
34393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34394       };
34395     } catch (std::exception& e) {
34396       {
34397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34398       };
34399     } catch (...) {
34400       {
34401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34402       };
34403     }
34404   }
34405   jresult = result;
34406   return jresult;
34407 }
34408
34409
34410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34411   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34412   Dali::Vector2 *arg2 = 0 ;
34413   Dali::RelayoutContainer *arg3 = 0 ;
34414
34415   arg1 = (Dali::CustomActorImpl *)jarg1;
34416   arg2 = (Dali::Vector2 *)jarg2;
34417   if (!arg2) {
34418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34419     return ;
34420   }
34421   arg3 = (Dali::RelayoutContainer *)jarg3;
34422   if (!arg3) {
34423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34424     return ;
34425   }
34426   {
34427     try {
34428       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34429     } catch (std::out_of_range& e) {
34430       {
34431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34432       };
34433     } catch (std::exception& e) {
34434       {
34435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34436       };
34437     } catch (...) {
34438       {
34439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34440       };
34441     }
34442   }
34443 }
34444
34445
34446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34447   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34448   Dali::ResizePolicy::Type arg2 ;
34449   Dali::Dimension::Type arg3 ;
34450
34451   arg1 = (Dali::CustomActorImpl *)jarg1;
34452   arg2 = (Dali::ResizePolicy::Type)jarg2;
34453   arg3 = (Dali::Dimension::Type)jarg3;
34454   {
34455     try {
34456       (arg1)->OnSetResizePolicy(arg2,arg3);
34457     } catch (std::out_of_range& e) {
34458       {
34459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34460       };
34461     } catch (std::exception& e) {
34462       {
34463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34464       };
34465     } catch (...) {
34466       {
34467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34468       };
34469     }
34470   }
34471 }
34472
34473
34474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34475   void * jresult ;
34476   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34477   Dali::Vector3 result;
34478
34479   arg1 = (Dali::CustomActorImpl *)jarg1;
34480   {
34481     try {
34482       result = (arg1)->GetNaturalSize();
34483     } catch (std::out_of_range& e) {
34484       {
34485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34486       };
34487     } catch (std::exception& e) {
34488       {
34489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34490       };
34491     } catch (...) {
34492       {
34493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34494       };
34495     }
34496   }
34497   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34498   return jresult;
34499 }
34500
34501
34502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34503   float jresult ;
34504   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34505   Dali::Actor *arg2 = 0 ;
34506   Dali::Dimension::Type arg3 ;
34507   float result;
34508
34509   arg1 = (Dali::CustomActorImpl *)jarg1;
34510   arg2 = (Dali::Actor *)jarg2;
34511   if (!arg2) {
34512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34513     return 0;
34514   }
34515   arg3 = (Dali::Dimension::Type)jarg3;
34516   {
34517     try {
34518       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34519     } catch (std::out_of_range& e) {
34520       {
34521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34522       };
34523     } catch (std::exception& e) {
34524       {
34525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34526       };
34527     } catch (...) {
34528       {
34529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34530       };
34531     }
34532   }
34533   jresult = result;
34534   return jresult;
34535 }
34536
34537
34538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34539   float jresult ;
34540   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34541   float arg2 ;
34542   float result;
34543
34544   arg1 = (Dali::CustomActorImpl *)jarg1;
34545   arg2 = (float)jarg2;
34546   {
34547     try {
34548       result = (float)(arg1)->GetHeightForWidth(arg2);
34549     } catch (std::out_of_range& e) {
34550       {
34551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34552       };
34553     } catch (std::exception& e) {
34554       {
34555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34556       };
34557     } catch (...) {
34558       {
34559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34560       };
34561     }
34562   }
34563   jresult = result;
34564   return jresult;
34565 }
34566
34567
34568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34569   float jresult ;
34570   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34571   float arg2 ;
34572   float result;
34573
34574   arg1 = (Dali::CustomActorImpl *)jarg1;
34575   arg2 = (float)jarg2;
34576   {
34577     try {
34578       result = (float)(arg1)->GetWidthForHeight(arg2);
34579     } catch (std::out_of_range& e) {
34580       {
34581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34582       };
34583     } catch (std::exception& e) {
34584       {
34585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34586       };
34587     } catch (...) {
34588       {
34589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34590       };
34591     }
34592   }
34593   jresult = result;
34594   return jresult;
34595 }
34596
34597
34598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34599   unsigned int jresult ;
34600   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34601   Dali::Dimension::Type arg2 ;
34602   bool result;
34603
34604   arg1 = (Dali::CustomActorImpl *)jarg1;
34605   arg2 = (Dali::Dimension::Type)jarg2;
34606   {
34607     try {
34608       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34609     } catch (std::out_of_range& e) {
34610       {
34611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34612       };
34613     } catch (std::exception& e) {
34614       {
34615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34616       };
34617     } catch (...) {
34618       {
34619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34620       };
34621     }
34622   }
34623   jresult = result;
34624   return jresult;
34625 }
34626
34627
34628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34629   unsigned int jresult ;
34630   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34631   bool result;
34632
34633   arg1 = (Dali::CustomActorImpl *)jarg1;
34634   {
34635     try {
34636       result = (bool)(arg1)->RelayoutDependentOnChildren();
34637     } catch (std::out_of_range& e) {
34638       {
34639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34640       };
34641     } catch (std::exception& e) {
34642       {
34643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34644       };
34645     } catch (...) {
34646       {
34647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34648       };
34649     }
34650   }
34651   jresult = result;
34652   return jresult;
34653 }
34654
34655
34656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34657   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34658   Dali::Dimension::Type arg2 ;
34659
34660   arg1 = (Dali::CustomActorImpl *)jarg1;
34661   arg2 = (Dali::Dimension::Type)jarg2;
34662   {
34663     try {
34664       (arg1)->OnCalculateRelayoutSize(arg2);
34665     } catch (std::out_of_range& e) {
34666       {
34667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34668       };
34669     } catch (std::exception& e) {
34670       {
34671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34672       };
34673     } catch (...) {
34674       {
34675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34676       };
34677     }
34678   }
34679 }
34680
34681
34682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34683   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34684   float arg2 ;
34685   Dali::Dimension::Type arg3 ;
34686
34687   arg1 = (Dali::CustomActorImpl *)jarg1;
34688   arg2 = (float)jarg2;
34689   arg3 = (Dali::Dimension::Type)jarg3;
34690   {
34691     try {
34692       (arg1)->OnLayoutNegotiated(arg2,arg3);
34693     } catch (std::out_of_range& e) {
34694       {
34695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34696       };
34697     } catch (std::exception& e) {
34698       {
34699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34700       };
34701     } catch (...) {
34702       {
34703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34704       };
34705     }
34706   }
34707 }
34708
34709
34710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34711   unsigned int jresult ;
34712   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34713   bool result;
34714
34715   arg1 = (Dali::CustomActorImpl *)jarg1;
34716   {
34717     try {
34718       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34719     } catch (std::out_of_range& e) {
34720       {
34721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34722       };
34723     } catch (std::exception& e) {
34724       {
34725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34726       };
34727     } catch (...) {
34728       {
34729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34730       };
34731     }
34732   }
34733   jresult = result;
34734   return jresult;
34735 }
34736
34737
34738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34739   unsigned int jresult ;
34740   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34741   bool result;
34742
34743   arg1 = (Dali::CustomActorImpl *)jarg1;
34744   {
34745     try {
34746       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34747     } catch (std::out_of_range& e) {
34748       {
34749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34750       };
34751     } catch (std::exception& e) {
34752       {
34753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34754       };
34755     } catch (...) {
34756       {
34757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34758       };
34759     }
34760   }
34761   jresult = result;
34762   return jresult;
34763 }
34764
34765
34766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34767   unsigned int jresult ;
34768   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34769   bool result;
34770
34771   arg1 = (Dali::CustomActorImpl *)jarg1;
34772   {
34773     try {
34774       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34775     } catch (std::out_of_range& e) {
34776       {
34777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34778       };
34779     } catch (std::exception& e) {
34780       {
34781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34782       };
34783     } catch (...) {
34784       {
34785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34786       };
34787     }
34788   }
34789   jresult = result;
34790   return jresult;
34791 }
34792
34793
34794 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34795   unsigned int jresult ;
34796   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34797   bool result;
34798
34799   arg1 = (Dali::CustomActorImpl *)jarg1;
34800   {
34801     try {
34802       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
34803     } catch (std::out_of_range& e) {
34804       {
34805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34806       };
34807     } catch (std::exception& e) {
34808       {
34809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34810       };
34811     } catch (...) {
34812       {
34813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34814       };
34815     }
34816   }
34817   jresult = result;
34818   return jresult;
34819 }
34820
34821
34822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34823   void * jresult ;
34824   Dali::CustomActor *result = 0 ;
34825
34826   {
34827     try {
34828       result = (Dali::CustomActor *)new Dali::CustomActor();
34829     } catch (std::out_of_range& e) {
34830       {
34831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34832       };
34833     } catch (std::exception& e) {
34834       {
34835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34836       };
34837     } catch (...) {
34838       {
34839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34840       };
34841     }
34842   }
34843   jresult = (void *)result;
34844   return jresult;
34845 }
34846
34847
34848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
34849   void * jresult ;
34850   Dali::BaseHandle arg1 ;
34851   Dali::BaseHandle *argp1 ;
34852   Dali::CustomActor result;
34853
34854   argp1 = (Dali::BaseHandle *)jarg1;
34855   if (!argp1) {
34856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
34857     return 0;
34858   }
34859   arg1 = *argp1;
34860   {
34861     try {
34862       result = Dali::CustomActor::DownCast(arg1);
34863     } catch (std::out_of_range& e) {
34864       {
34865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34866       };
34867     } catch (std::exception& e) {
34868       {
34869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34870       };
34871     } catch (...) {
34872       {
34873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34874       };
34875     }
34876   }
34877   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34878   return jresult;
34879 }
34880
34881
34882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
34883   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34884
34885   arg1 = (Dali::CustomActor *)jarg1;
34886   {
34887     try {
34888       delete arg1;
34889     } catch (std::out_of_range& e) {
34890       {
34891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34892       };
34893     } catch (std::exception& e) {
34894       {
34895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34896       };
34897     } catch (...) {
34898       {
34899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34900       };
34901     }
34902   }
34903 }
34904
34905
34906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
34907   void * jresult ;
34908   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
34909   Dali::CustomActorImpl *result = 0 ;
34910
34911   arg1 = (Dali::CustomActor *)jarg1;
34912   {
34913     try {
34914       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
34915     } catch (std::out_of_range& e) {
34916       {
34917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34918       };
34919     } catch (std::exception& e) {
34920       {
34921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34922       };
34923     } catch (...) {
34924       {
34925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34926       };
34927     }
34928   }
34929   jresult = (void *)result;
34930   return jresult;
34931 }
34932
34933
34934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
34935   void * jresult ;
34936   Dali::CustomActorImpl *arg1 = 0 ;
34937   Dali::CustomActor *result = 0 ;
34938
34939   arg1 = (Dali::CustomActorImpl *)jarg1;
34940   if (!arg1) {
34941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
34942     return 0;
34943   }
34944   {
34945     try {
34946       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
34947     } catch (std::out_of_range& e) {
34948       {
34949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34950       };
34951     } catch (std::exception& e) {
34952       {
34953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34954       };
34955     } catch (...) {
34956       {
34957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34958       };
34959     }
34960   }
34961   jresult = (void *)result;
34962   return jresult;
34963 }
34964
34965
34966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
34967   void * jresult ;
34968   Dali::CustomActor *arg1 = 0 ;
34969   Dali::CustomActor *result = 0 ;
34970
34971   arg1 = (Dali::CustomActor *)jarg1;
34972   if (!arg1) {
34973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
34974     return 0;
34975   }
34976   {
34977     try {
34978       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
34979     } catch (std::out_of_range& e) {
34980       {
34981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34982       };
34983     } catch (std::exception& e) {
34984       {
34985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34986       };
34987     } catch (...) {
34988       {
34989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34990       };
34991     }
34992   }
34993   jresult = (void *)result;
34994   return jresult;
34995 }
34996
34997
34998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
34999   void * jresult ;
35000   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35001   Dali::CustomActor *arg2 = 0 ;
35002   Dali::CustomActor *result = 0 ;
35003
35004   arg1 = (Dali::CustomActor *)jarg1;
35005   arg2 = (Dali::CustomActor *)jarg2;
35006   if (!arg2) {
35007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35008     return 0;
35009   }
35010   {
35011     try {
35012       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35013     } catch (std::out_of_range& e) {
35014       {
35015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35016       };
35017     } catch (std::exception& e) {
35018       {
35019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35020       };
35021     } catch (...) {
35022       {
35023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35024       };
35025     }
35026   }
35027   jresult = (void *)result;
35028   return jresult;
35029 }
35030
35031
35032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35033   int jresult ;
35034   int result;
35035
35036   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35037   jresult = (int)result;
35038   return jresult;
35039 }
35040
35041
35042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35043   int jresult ;
35044   int result;
35045
35046   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35047   jresult = (int)result;
35048   return jresult;
35049 }
35050
35051
35052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35053   int jresult ;
35054   int result;
35055
35056   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35057   jresult = (int)result;
35058   return jresult;
35059 }
35060
35061
35062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35063   int jresult ;
35064   int result;
35065
35066   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35067   jresult = (int)result;
35068   return jresult;
35069 }
35070
35071
35072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35073   int jresult ;
35074   int result;
35075
35076   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35077   jresult = (int)result;
35078   return jresult;
35079 }
35080
35081
35082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35083   int jresult ;
35084   int result;
35085
35086   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35087   jresult = (int)result;
35088   return jresult;
35089 }
35090
35091
35092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35093   int jresult ;
35094   int result;
35095
35096   result = (int)Dali::PanGestureDetector::Property::PANNING;
35097   jresult = (int)result;
35098   return jresult;
35099 }
35100
35101
35102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35103   void * jresult ;
35104   Dali::PanGestureDetector::Property *result = 0 ;
35105
35106   {
35107     try {
35108       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35109     } catch (std::out_of_range& e) {
35110       {
35111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35112       };
35113     } catch (std::exception& e) {
35114       {
35115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35116       };
35117     } catch (...) {
35118       {
35119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35120       };
35121     }
35122   }
35123   jresult = (void *)result;
35124   return jresult;
35125 }
35126
35127
35128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35129   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35130
35131   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35132   {
35133     try {
35134       delete arg1;
35135     } catch (std::out_of_range& e) {
35136       {
35137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35138       };
35139     } catch (std::exception& e) {
35140       {
35141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35142       };
35143     } catch (...) {
35144       {
35145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35146       };
35147     }
35148   }
35149 }
35150
35151
35152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35153   void * jresult ;
35154   Dali::Radian *result = 0 ;
35155
35156   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35157   jresult = (void *)result;
35158   return jresult;
35159 }
35160
35161
35162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35163   void * jresult ;
35164   Dali::Radian *result = 0 ;
35165
35166   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35167   jresult = (void *)result;
35168   return jresult;
35169 }
35170
35171
35172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35173   void * jresult ;
35174   Dali::Radian *result = 0 ;
35175
35176   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35177   jresult = (void *)result;
35178   return jresult;
35179 }
35180
35181
35182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35183   void * jresult ;
35184   Dali::Radian *result = 0 ;
35185
35186   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35187   jresult = (void *)result;
35188   return jresult;
35189 }
35190
35191
35192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35193   void * jresult ;
35194   Dali::Radian *result = 0 ;
35195
35196   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35197   jresult = (void *)result;
35198   return jresult;
35199 }
35200
35201
35202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35203   void * jresult ;
35204   Dali::Radian *result = 0 ;
35205
35206   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35207   jresult = (void *)result;
35208   return jresult;
35209 }
35210
35211
35212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35213   void * jresult ;
35214   Dali::Radian *result = 0 ;
35215
35216   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35217   jresult = (void *)result;
35218   return jresult;
35219 }
35220
35221
35222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35223   void * jresult ;
35224   Dali::PanGestureDetector *result = 0 ;
35225
35226   {
35227     try {
35228       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35229     } catch (std::out_of_range& e) {
35230       {
35231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35232       };
35233     } catch (std::exception& e) {
35234       {
35235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35236       };
35237     } catch (...) {
35238       {
35239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35240       };
35241     }
35242   }
35243   jresult = (void *)result;
35244   return jresult;
35245 }
35246
35247
35248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35249   void * jresult ;
35250   Dali::PanGestureDetector result;
35251
35252   {
35253     try {
35254       result = Dali::PanGestureDetector::New();
35255     } catch (std::out_of_range& e) {
35256       {
35257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35258       };
35259     } catch (std::exception& e) {
35260       {
35261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35262       };
35263     } catch (...) {
35264       {
35265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35266       };
35267     }
35268   }
35269   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35270   return jresult;
35271 }
35272
35273
35274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35275   void * jresult ;
35276   Dali::BaseHandle arg1 ;
35277   Dali::BaseHandle *argp1 ;
35278   Dali::PanGestureDetector result;
35279
35280   argp1 = (Dali::BaseHandle *)jarg1;
35281   if (!argp1) {
35282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35283     return 0;
35284   }
35285   arg1 = *argp1;
35286   {
35287     try {
35288       result = Dali::PanGestureDetector::DownCast(arg1);
35289     } catch (std::out_of_range& e) {
35290       {
35291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35292       };
35293     } catch (std::exception& e) {
35294       {
35295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35296       };
35297     } catch (...) {
35298       {
35299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35300       };
35301     }
35302   }
35303   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35304   return jresult;
35305 }
35306
35307
35308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35309   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35310
35311   arg1 = (Dali::PanGestureDetector *)jarg1;
35312   {
35313     try {
35314       delete arg1;
35315     } catch (std::out_of_range& e) {
35316       {
35317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35318       };
35319     } catch (std::exception& e) {
35320       {
35321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35322       };
35323     } catch (...) {
35324       {
35325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35326       };
35327     }
35328   }
35329 }
35330
35331
35332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35333   void * jresult ;
35334   Dali::PanGestureDetector *arg1 = 0 ;
35335   Dali::PanGestureDetector *result = 0 ;
35336
35337   arg1 = (Dali::PanGestureDetector *)jarg1;
35338   if (!arg1) {
35339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35340     return 0;
35341   }
35342   {
35343     try {
35344       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35345     } catch (std::out_of_range& e) {
35346       {
35347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35348       };
35349     } catch (std::exception& e) {
35350       {
35351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35352       };
35353     } catch (...) {
35354       {
35355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35356       };
35357     }
35358   }
35359   jresult = (void *)result;
35360   return jresult;
35361 }
35362
35363
35364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35365   void * jresult ;
35366   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35367   Dali::PanGestureDetector *arg2 = 0 ;
35368   Dali::PanGestureDetector *result = 0 ;
35369
35370   arg1 = (Dali::PanGestureDetector *)jarg1;
35371   arg2 = (Dali::PanGestureDetector *)jarg2;
35372   if (!arg2) {
35373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35374     return 0;
35375   }
35376   {
35377     try {
35378       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35379     } catch (std::out_of_range& e) {
35380       {
35381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35382       };
35383     } catch (std::exception& e) {
35384       {
35385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35386       };
35387     } catch (...) {
35388       {
35389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35390       };
35391     }
35392   }
35393   jresult = (void *)result;
35394   return jresult;
35395 }
35396
35397
35398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35399   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35400   unsigned int arg2 ;
35401
35402   arg1 = (Dali::PanGestureDetector *)jarg1;
35403   arg2 = (unsigned int)jarg2;
35404   {
35405     try {
35406       (arg1)->SetMinimumTouchesRequired(arg2);
35407     } catch (std::out_of_range& e) {
35408       {
35409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35410       };
35411     } catch (std::exception& e) {
35412       {
35413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35414       };
35415     } catch (...) {
35416       {
35417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35418       };
35419     }
35420   }
35421 }
35422
35423
35424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35425   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35426   unsigned int arg2 ;
35427
35428   arg1 = (Dali::PanGestureDetector *)jarg1;
35429   arg2 = (unsigned int)jarg2;
35430   {
35431     try {
35432       (arg1)->SetMaximumTouchesRequired(arg2);
35433     } catch (std::out_of_range& e) {
35434       {
35435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35436       };
35437     } catch (std::exception& e) {
35438       {
35439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35440       };
35441     } catch (...) {
35442       {
35443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35444       };
35445     }
35446   }
35447 }
35448
35449
35450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35451   unsigned int jresult ;
35452   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35453   unsigned int result;
35454
35455   arg1 = (Dali::PanGestureDetector *)jarg1;
35456   {
35457     try {
35458       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35459     } catch (std::out_of_range& e) {
35460       {
35461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35462       };
35463     } catch (std::exception& e) {
35464       {
35465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35466       };
35467     } catch (...) {
35468       {
35469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35470       };
35471     }
35472   }
35473   jresult = result;
35474   return jresult;
35475 }
35476
35477
35478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35479   unsigned int jresult ;
35480   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35481   unsigned int result;
35482
35483   arg1 = (Dali::PanGestureDetector *)jarg1;
35484   {
35485     try {
35486       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35487     } catch (std::out_of_range& e) {
35488       {
35489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35490       };
35491     } catch (std::exception& e) {
35492       {
35493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35494       };
35495     } catch (...) {
35496       {
35497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35498       };
35499     }
35500   }
35501   jresult = result;
35502   return jresult;
35503 }
35504
35505
35506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35507   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35508   Dali::Radian arg2 ;
35509   Dali::Radian arg3 ;
35510   Dali::Radian *argp2 ;
35511   Dali::Radian *argp3 ;
35512
35513   arg1 = (Dali::PanGestureDetector *)jarg1;
35514   argp2 = (Dali::Radian *)jarg2;
35515   if (!argp2) {
35516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35517     return ;
35518   }
35519   arg2 = *argp2;
35520   argp3 = (Dali::Radian *)jarg3;
35521   if (!argp3) {
35522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35523     return ;
35524   }
35525   arg3 = *argp3;
35526   {
35527     try {
35528       (arg1)->AddAngle(arg2,arg3);
35529     } catch (std::out_of_range& e) {
35530       {
35531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35532       };
35533     } catch (std::exception& e) {
35534       {
35535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35536       };
35537     } catch (...) {
35538       {
35539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35540       };
35541     }
35542   }
35543 }
35544
35545
35546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35547   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35548   Dali::Radian arg2 ;
35549   Dali::Radian *argp2 ;
35550
35551   arg1 = (Dali::PanGestureDetector *)jarg1;
35552   argp2 = (Dali::Radian *)jarg2;
35553   if (!argp2) {
35554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35555     return ;
35556   }
35557   arg2 = *argp2;
35558   {
35559     try {
35560       (arg1)->AddAngle(arg2);
35561     } catch (std::out_of_range& e) {
35562       {
35563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35564       };
35565     } catch (std::exception& e) {
35566       {
35567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35568       };
35569     } catch (...) {
35570       {
35571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35572       };
35573     }
35574   }
35575 }
35576
35577
35578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35579   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35580   Dali::Radian arg2 ;
35581   Dali::Radian arg3 ;
35582   Dali::Radian *argp2 ;
35583   Dali::Radian *argp3 ;
35584
35585   arg1 = (Dali::PanGestureDetector *)jarg1;
35586   argp2 = (Dali::Radian *)jarg2;
35587   if (!argp2) {
35588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35589     return ;
35590   }
35591   arg2 = *argp2;
35592   argp3 = (Dali::Radian *)jarg3;
35593   if (!argp3) {
35594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35595     return ;
35596   }
35597   arg3 = *argp3;
35598   {
35599     try {
35600       (arg1)->AddDirection(arg2,arg3);
35601     } catch (std::out_of_range& e) {
35602       {
35603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35604       };
35605     } catch (std::exception& e) {
35606       {
35607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35608       };
35609     } catch (...) {
35610       {
35611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35612       };
35613     }
35614   }
35615 }
35616
35617
35618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35619   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35620   Dali::Radian arg2 ;
35621   Dali::Radian *argp2 ;
35622
35623   arg1 = (Dali::PanGestureDetector *)jarg1;
35624   argp2 = (Dali::Radian *)jarg2;
35625   if (!argp2) {
35626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35627     return ;
35628   }
35629   arg2 = *argp2;
35630   {
35631     try {
35632       (arg1)->AddDirection(arg2);
35633     } catch (std::out_of_range& e) {
35634       {
35635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35636       };
35637     } catch (std::exception& e) {
35638       {
35639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35640       };
35641     } catch (...) {
35642       {
35643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35644       };
35645     }
35646   }
35647 }
35648
35649
35650 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35651   unsigned long jresult ;
35652   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35653   size_t result;
35654
35655   arg1 = (Dali::PanGestureDetector *)jarg1;
35656   {
35657     try {
35658       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35659     } catch (std::out_of_range& e) {
35660       {
35661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35662       };
35663     } catch (std::exception& e) {
35664       {
35665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35666       };
35667     } catch (...) {
35668       {
35669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35670       };
35671     }
35672   }
35673   jresult = (unsigned long)result;
35674   return jresult;
35675 }
35676
35677
35678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35679   void * jresult ;
35680   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35681   size_t arg2 ;
35682   Dali::PanGestureDetector::AngleThresholdPair result;
35683
35684   arg1 = (Dali::PanGestureDetector *)jarg1;
35685   arg2 = (size_t)jarg2;
35686   {
35687     try {
35688       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35689     } catch (std::out_of_range& e) {
35690       {
35691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35692       };
35693     } catch (std::exception& e) {
35694       {
35695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35696       };
35697     } catch (...) {
35698       {
35699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35700       };
35701     }
35702   }
35703   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35704   return jresult;
35705 }
35706
35707
35708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35709   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35710
35711   arg1 = (Dali::PanGestureDetector *)jarg1;
35712   {
35713     try {
35714       (arg1)->ClearAngles();
35715     } catch (std::out_of_range& e) {
35716       {
35717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35718       };
35719     } catch (std::exception& e) {
35720       {
35721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35722       };
35723     } catch (...) {
35724       {
35725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35726       };
35727     }
35728   }
35729 }
35730
35731
35732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35733   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35734   Dali::Radian arg2 ;
35735   Dali::Radian *argp2 ;
35736
35737   arg1 = (Dali::PanGestureDetector *)jarg1;
35738   argp2 = (Dali::Radian *)jarg2;
35739   if (!argp2) {
35740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35741     return ;
35742   }
35743   arg2 = *argp2;
35744   {
35745     try {
35746       (arg1)->RemoveAngle(arg2);
35747     } catch (std::out_of_range& e) {
35748       {
35749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35750       };
35751     } catch (std::exception& e) {
35752       {
35753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35754       };
35755     } catch (...) {
35756       {
35757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35758       };
35759     }
35760   }
35761 }
35762
35763
35764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35765   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35766   Dali::Radian arg2 ;
35767   Dali::Radian *argp2 ;
35768
35769   arg1 = (Dali::PanGestureDetector *)jarg1;
35770   argp2 = (Dali::Radian *)jarg2;
35771   if (!argp2) {
35772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35773     return ;
35774   }
35775   arg2 = *argp2;
35776   {
35777     try {
35778       (arg1)->RemoveDirection(arg2);
35779     } catch (std::out_of_range& e) {
35780       {
35781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35782       };
35783     } catch (std::exception& e) {
35784       {
35785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35786       };
35787     } catch (...) {
35788       {
35789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35790       };
35791     }
35792   }
35793 }
35794
35795
35796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35797   void * jresult ;
35798   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35799   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35800
35801   arg1 = (Dali::PanGestureDetector *)jarg1;
35802   {
35803     try {
35804       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35805     } catch (std::out_of_range& e) {
35806       {
35807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35808       };
35809     } catch (std::exception& e) {
35810       {
35811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35812       };
35813     } catch (...) {
35814       {
35815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35816       };
35817     }
35818   }
35819   jresult = (void *)result;
35820   return jresult;
35821 }
35822
35823
35824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
35825   Dali::PanGesture *arg1 = 0 ;
35826
35827   arg1 = (Dali::PanGesture *)jarg1;
35828   if (!arg1) {
35829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35830     return ;
35831   }
35832   {
35833     try {
35834       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
35835     } catch (std::out_of_range& e) {
35836       {
35837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35838       };
35839     } catch (std::exception& e) {
35840       {
35841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35842       };
35843     } catch (...) {
35844       {
35845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35846       };
35847     }
35848   }
35849 }
35850
35851
35852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
35853   void * jresult ;
35854   Dali::PanGesture *result = 0 ;
35855
35856   {
35857     try {
35858       result = (Dali::PanGesture *)new Dali::PanGesture();
35859     } catch (std::out_of_range& e) {
35860       {
35861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35862       };
35863     } catch (std::exception& e) {
35864       {
35865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35866       };
35867     } catch (...) {
35868       {
35869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35870       };
35871     }
35872   }
35873   jresult = (void *)result;
35874   return jresult;
35875 }
35876
35877
35878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
35879   void * jresult ;
35880   Dali::Gesture::State arg1 ;
35881   Dali::PanGesture *result = 0 ;
35882
35883   arg1 = (Dali::Gesture::State)jarg1;
35884   {
35885     try {
35886       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
35887     } catch (std::out_of_range& e) {
35888       {
35889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35890       };
35891     } catch (std::exception& e) {
35892       {
35893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35894       };
35895     } catch (...) {
35896       {
35897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35898       };
35899     }
35900   }
35901   jresult = (void *)result;
35902   return jresult;
35903 }
35904
35905
35906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
35907   void * jresult ;
35908   Dali::PanGesture *arg1 = 0 ;
35909   Dali::PanGesture *result = 0 ;
35910
35911   arg1 = (Dali::PanGesture *)jarg1;
35912   if (!arg1) {
35913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35914     return 0;
35915   }
35916   {
35917     try {
35918       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
35919     } catch (std::out_of_range& e) {
35920       {
35921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35922       };
35923     } catch (std::exception& e) {
35924       {
35925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35926       };
35927     } catch (...) {
35928       {
35929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35930       };
35931     }
35932   }
35933   jresult = (void *)result;
35934   return jresult;
35935 }
35936
35937
35938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
35939   void * jresult ;
35940   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35941   Dali::PanGesture *arg2 = 0 ;
35942   Dali::PanGesture *result = 0 ;
35943
35944   arg1 = (Dali::PanGesture *)jarg1;
35945   arg2 = (Dali::PanGesture *)jarg2;
35946   if (!arg2) {
35947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
35948     return 0;
35949   }
35950   {
35951     try {
35952       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
35953     } catch (std::out_of_range& e) {
35954       {
35955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35956       };
35957     } catch (std::exception& e) {
35958       {
35959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35960       };
35961     } catch (...) {
35962       {
35963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35964       };
35965     }
35966   }
35967   jresult = (void *)result;
35968   return jresult;
35969 }
35970
35971
35972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
35973   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35974
35975   arg1 = (Dali::PanGesture *)jarg1;
35976   {
35977     try {
35978       delete arg1;
35979     } catch (std::out_of_range& e) {
35980       {
35981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35982       };
35983     } catch (std::exception& e) {
35984       {
35985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35986       };
35987     } catch (...) {
35988       {
35989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35990       };
35991     }
35992   }
35993 }
35994
35995
35996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
35997   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
35998   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
35999
36000   arg1 = (Dali::PanGesture *)jarg1;
36001   arg2 = (Dali::Vector2 *)jarg2;
36002   if (arg1) (arg1)->velocity = *arg2;
36003 }
36004
36005
36006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36007   void * jresult ;
36008   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36009   Dali::Vector2 *result = 0 ;
36010
36011   arg1 = (Dali::PanGesture *)jarg1;
36012   result = (Dali::Vector2 *)& ((arg1)->velocity);
36013   jresult = (void *)result;
36014   return jresult;
36015 }
36016
36017
36018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36019   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36020   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36021
36022   arg1 = (Dali::PanGesture *)jarg1;
36023   arg2 = (Dali::Vector2 *)jarg2;
36024   if (arg1) (arg1)->displacement = *arg2;
36025 }
36026
36027
36028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36029   void * jresult ;
36030   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36031   Dali::Vector2 *result = 0 ;
36032
36033   arg1 = (Dali::PanGesture *)jarg1;
36034   result = (Dali::Vector2 *)& ((arg1)->displacement);
36035   jresult = (void *)result;
36036   return jresult;
36037 }
36038
36039
36040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36041   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36042   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36043
36044   arg1 = (Dali::PanGesture *)jarg1;
36045   arg2 = (Dali::Vector2 *)jarg2;
36046   if (arg1) (arg1)->position = *arg2;
36047 }
36048
36049
36050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36051   void * jresult ;
36052   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36053   Dali::Vector2 *result = 0 ;
36054
36055   arg1 = (Dali::PanGesture *)jarg1;
36056   result = (Dali::Vector2 *)& ((arg1)->position);
36057   jresult = (void *)result;
36058   return jresult;
36059 }
36060
36061
36062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36063   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36064   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36065
36066   arg1 = (Dali::PanGesture *)jarg1;
36067   arg2 = (Dali::Vector2 *)jarg2;
36068   if (arg1) (arg1)->screenVelocity = *arg2;
36069 }
36070
36071
36072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36073   void * jresult ;
36074   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36075   Dali::Vector2 *result = 0 ;
36076
36077   arg1 = (Dali::PanGesture *)jarg1;
36078   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36079   jresult = (void *)result;
36080   return jresult;
36081 }
36082
36083
36084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36085   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36086   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36087
36088   arg1 = (Dali::PanGesture *)jarg1;
36089   arg2 = (Dali::Vector2 *)jarg2;
36090   if (arg1) (arg1)->screenDisplacement = *arg2;
36091 }
36092
36093
36094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36095   void * jresult ;
36096   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36097   Dali::Vector2 *result = 0 ;
36098
36099   arg1 = (Dali::PanGesture *)jarg1;
36100   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36101   jresult = (void *)result;
36102   return jresult;
36103 }
36104
36105
36106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36107   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36108   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36109
36110   arg1 = (Dali::PanGesture *)jarg1;
36111   arg2 = (Dali::Vector2 *)jarg2;
36112   if (arg1) (arg1)->screenPosition = *arg2;
36113 }
36114
36115
36116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36117   void * jresult ;
36118   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36119   Dali::Vector2 *result = 0 ;
36120
36121   arg1 = (Dali::PanGesture *)jarg1;
36122   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36123   jresult = (void *)result;
36124   return jresult;
36125 }
36126
36127
36128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36129   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36130   unsigned int arg2 ;
36131
36132   arg1 = (Dali::PanGesture *)jarg1;
36133   arg2 = (unsigned int)jarg2;
36134   if (arg1) (arg1)->numberOfTouches = arg2;
36135 }
36136
36137
36138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36139   unsigned int jresult ;
36140   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36141   unsigned int result;
36142
36143   arg1 = (Dali::PanGesture *)jarg1;
36144   result = (unsigned int) ((arg1)->numberOfTouches);
36145   jresult = result;
36146   return jresult;
36147 }
36148
36149
36150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36151   float jresult ;
36152   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36153   float result;
36154
36155   arg1 = (Dali::PanGesture *)jarg1;
36156   {
36157     try {
36158       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36159     } catch (std::out_of_range& e) {
36160       {
36161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36162       };
36163     } catch (std::exception& e) {
36164       {
36165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36166       };
36167     } catch (...) {
36168       {
36169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36170       };
36171     }
36172   }
36173   jresult = result;
36174   return jresult;
36175 }
36176
36177
36178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36179   float jresult ;
36180   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36181   float result;
36182
36183   arg1 = (Dali::PanGesture *)jarg1;
36184   {
36185     try {
36186       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36187     } catch (std::out_of_range& e) {
36188       {
36189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36190       };
36191     } catch (std::exception& e) {
36192       {
36193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36194       };
36195     } catch (...) {
36196       {
36197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36198       };
36199     }
36200   }
36201   jresult = result;
36202   return jresult;
36203 }
36204
36205
36206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36207   float jresult ;
36208   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36209   float result;
36210
36211   arg1 = (Dali::PanGesture *)jarg1;
36212   {
36213     try {
36214       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36215     } catch (std::out_of_range& e) {
36216       {
36217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36218       };
36219     } catch (std::exception& e) {
36220       {
36221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36222       };
36223     } catch (...) {
36224       {
36225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36226       };
36227     }
36228   }
36229   jresult = result;
36230   return jresult;
36231 }
36232
36233
36234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36235   float jresult ;
36236   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36237   float result;
36238
36239   arg1 = (Dali::PanGesture *)jarg1;
36240   {
36241     try {
36242       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
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 (...) {
36252       {
36253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36254       };
36255     }
36256   }
36257   jresult = result;
36258   return jresult;
36259 }
36260
36261
36262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36263   void * jresult ;
36264   Dali::PinchGestureDetector *result = 0 ;
36265
36266   {
36267     try {
36268       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36269     } catch (std::out_of_range& e) {
36270       {
36271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36272       };
36273     } catch (std::exception& e) {
36274       {
36275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36276       };
36277     } catch (...) {
36278       {
36279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36280       };
36281     }
36282   }
36283   jresult = (void *)result;
36284   return jresult;
36285 }
36286
36287
36288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36289   void * jresult ;
36290   Dali::PinchGestureDetector result;
36291
36292   {
36293     try {
36294       result = Dali::PinchGestureDetector::New();
36295     } catch (std::out_of_range& e) {
36296       {
36297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36298       };
36299     } catch (std::exception& e) {
36300       {
36301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36302       };
36303     } catch (...) {
36304       {
36305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36306       };
36307     }
36308   }
36309   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36310   return jresult;
36311 }
36312
36313
36314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36315   void * jresult ;
36316   Dali::BaseHandle arg1 ;
36317   Dali::BaseHandle *argp1 ;
36318   Dali::PinchGestureDetector result;
36319
36320   argp1 = (Dali::BaseHandle *)jarg1;
36321   if (!argp1) {
36322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36323     return 0;
36324   }
36325   arg1 = *argp1;
36326   {
36327     try {
36328       result = Dali::PinchGestureDetector::DownCast(arg1);
36329     } catch (std::out_of_range& e) {
36330       {
36331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36332       };
36333     } catch (std::exception& e) {
36334       {
36335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36336       };
36337     } catch (...) {
36338       {
36339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36340       };
36341     }
36342   }
36343   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36344   return jresult;
36345 }
36346
36347
36348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36349   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36350
36351   arg1 = (Dali::PinchGestureDetector *)jarg1;
36352   {
36353     try {
36354       delete arg1;
36355     } catch (std::out_of_range& e) {
36356       {
36357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36358       };
36359     } catch (std::exception& e) {
36360       {
36361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36362       };
36363     } catch (...) {
36364       {
36365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36366       };
36367     }
36368   }
36369 }
36370
36371
36372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36373   void * jresult ;
36374   Dali::PinchGestureDetector *arg1 = 0 ;
36375   Dali::PinchGestureDetector *result = 0 ;
36376
36377   arg1 = (Dali::PinchGestureDetector *)jarg1;
36378   if (!arg1) {
36379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36380     return 0;
36381   }
36382   {
36383     try {
36384       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36385     } catch (std::out_of_range& e) {
36386       {
36387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36388       };
36389     } catch (std::exception& e) {
36390       {
36391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36392       };
36393     } catch (...) {
36394       {
36395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36396       };
36397     }
36398   }
36399   jresult = (void *)result;
36400   return jresult;
36401 }
36402
36403
36404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36405   void * jresult ;
36406   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36407   Dali::PinchGestureDetector *arg2 = 0 ;
36408   Dali::PinchGestureDetector *result = 0 ;
36409
36410   arg1 = (Dali::PinchGestureDetector *)jarg1;
36411   arg2 = (Dali::PinchGestureDetector *)jarg2;
36412   if (!arg2) {
36413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36414     return 0;
36415   }
36416   {
36417     try {
36418       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36419     } catch (std::out_of_range& e) {
36420       {
36421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36422       };
36423     } catch (std::exception& e) {
36424       {
36425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36426       };
36427     } catch (...) {
36428       {
36429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36430       };
36431     }
36432   }
36433   jresult = (void *)result;
36434   return jresult;
36435 }
36436
36437
36438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36439   void * jresult ;
36440   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36441   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36442
36443   arg1 = (Dali::PinchGestureDetector *)jarg1;
36444   {
36445     try {
36446       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36447     } catch (std::out_of_range& e) {
36448       {
36449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36450       };
36451     } catch (std::exception& e) {
36452       {
36453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36454       };
36455     } catch (...) {
36456       {
36457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36458       };
36459     }
36460   }
36461   jresult = (void *)result;
36462   return jresult;
36463 }
36464
36465
36466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36467   void * jresult ;
36468   Dali::Gesture::State arg1 ;
36469   Dali::PinchGesture *result = 0 ;
36470
36471   arg1 = (Dali::Gesture::State)jarg1;
36472   {
36473     try {
36474       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36475     } catch (std::out_of_range& e) {
36476       {
36477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36478       };
36479     } catch (std::exception& e) {
36480       {
36481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36482       };
36483     } catch (...) {
36484       {
36485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36486       };
36487     }
36488   }
36489   jresult = (void *)result;
36490   return jresult;
36491 }
36492
36493
36494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36495   void * jresult ;
36496   Dali::PinchGesture *arg1 = 0 ;
36497   Dali::PinchGesture *result = 0 ;
36498
36499   arg1 = (Dali::PinchGesture *)jarg1;
36500   if (!arg1) {
36501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36502     return 0;
36503   }
36504   {
36505     try {
36506       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36507     } catch (std::out_of_range& e) {
36508       {
36509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36510       };
36511     } catch (std::exception& e) {
36512       {
36513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36514       };
36515     } catch (...) {
36516       {
36517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36518       };
36519     }
36520   }
36521   jresult = (void *)result;
36522   return jresult;
36523 }
36524
36525
36526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36527   void * jresult ;
36528   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36529   Dali::PinchGesture *arg2 = 0 ;
36530   Dali::PinchGesture *result = 0 ;
36531
36532   arg1 = (Dali::PinchGesture *)jarg1;
36533   arg2 = (Dali::PinchGesture *)jarg2;
36534   if (!arg2) {
36535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36536     return 0;
36537   }
36538   {
36539     try {
36540       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36541     } catch (std::out_of_range& e) {
36542       {
36543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36544       };
36545     } catch (std::exception& e) {
36546       {
36547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36548       };
36549     } catch (...) {
36550       {
36551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36552       };
36553     }
36554   }
36555   jresult = (void *)result;
36556   return jresult;
36557 }
36558
36559
36560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36561   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36562
36563   arg1 = (Dali::PinchGesture *)jarg1;
36564   {
36565     try {
36566       delete arg1;
36567     } catch (std::out_of_range& e) {
36568       {
36569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36570       };
36571     } catch (std::exception& e) {
36572       {
36573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36574       };
36575     } catch (...) {
36576       {
36577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36578       };
36579     }
36580   }
36581 }
36582
36583
36584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36585   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36586   float arg2 ;
36587
36588   arg1 = (Dali::PinchGesture *)jarg1;
36589   arg2 = (float)jarg2;
36590   if (arg1) (arg1)->scale = arg2;
36591 }
36592
36593
36594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36595   float jresult ;
36596   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36597   float result;
36598
36599   arg1 = (Dali::PinchGesture *)jarg1;
36600   result = (float) ((arg1)->scale);
36601   jresult = result;
36602   return jresult;
36603 }
36604
36605
36606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36607   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36608   float arg2 ;
36609
36610   arg1 = (Dali::PinchGesture *)jarg1;
36611   arg2 = (float)jarg2;
36612   if (arg1) (arg1)->speed = arg2;
36613 }
36614
36615
36616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36617   float jresult ;
36618   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36619   float result;
36620
36621   arg1 = (Dali::PinchGesture *)jarg1;
36622   result = (float) ((arg1)->speed);
36623   jresult = result;
36624   return jresult;
36625 }
36626
36627
36628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36629   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36630   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36631
36632   arg1 = (Dali::PinchGesture *)jarg1;
36633   arg2 = (Dali::Vector2 *)jarg2;
36634   if (arg1) (arg1)->screenCenterPoint = *arg2;
36635 }
36636
36637
36638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36639   void * jresult ;
36640   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36641   Dali::Vector2 *result = 0 ;
36642
36643   arg1 = (Dali::PinchGesture *)jarg1;
36644   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36645   jresult = (void *)result;
36646   return jresult;
36647 }
36648
36649
36650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36651   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36652   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36653
36654   arg1 = (Dali::PinchGesture *)jarg1;
36655   arg2 = (Dali::Vector2 *)jarg2;
36656   if (arg1) (arg1)->localCenterPoint = *arg2;
36657 }
36658
36659
36660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36661   void * jresult ;
36662   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36663   Dali::Vector2 *result = 0 ;
36664
36665   arg1 = (Dali::PinchGesture *)jarg1;
36666   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36667   jresult = (void *)result;
36668   return jresult;
36669 }
36670
36671
36672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36673   void * jresult ;
36674   Dali::TapGestureDetector *result = 0 ;
36675
36676   {
36677     try {
36678       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36679     } catch (std::out_of_range& e) {
36680       {
36681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36682       };
36683     } catch (std::exception& e) {
36684       {
36685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36686       };
36687     } catch (...) {
36688       {
36689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36690       };
36691     }
36692   }
36693   jresult = (void *)result;
36694   return jresult;
36695 }
36696
36697
36698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36699   void * jresult ;
36700   Dali::TapGestureDetector result;
36701
36702   {
36703     try {
36704       result = Dali::TapGestureDetector::New();
36705     } catch (std::out_of_range& e) {
36706       {
36707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36708       };
36709     } catch (std::exception& e) {
36710       {
36711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36712       };
36713     } catch (...) {
36714       {
36715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36716       };
36717     }
36718   }
36719   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36720   return jresult;
36721 }
36722
36723
36724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36725   void * jresult ;
36726   unsigned int arg1 ;
36727   Dali::TapGestureDetector result;
36728
36729   arg1 = (unsigned int)jarg1;
36730   {
36731     try {
36732       result = Dali::TapGestureDetector::New(arg1);
36733     } catch (std::out_of_range& e) {
36734       {
36735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36736       };
36737     } catch (std::exception& e) {
36738       {
36739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36740       };
36741     } catch (...) {
36742       {
36743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36744       };
36745     }
36746   }
36747   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36748   return jresult;
36749 }
36750
36751
36752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36753   void * jresult ;
36754   Dali::BaseHandle arg1 ;
36755   Dali::BaseHandle *argp1 ;
36756   Dali::TapGestureDetector result;
36757
36758   argp1 = (Dali::BaseHandle *)jarg1;
36759   if (!argp1) {
36760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36761     return 0;
36762   }
36763   arg1 = *argp1;
36764   {
36765     try {
36766       result = Dali::TapGestureDetector::DownCast(arg1);
36767     } catch (std::out_of_range& e) {
36768       {
36769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36770       };
36771     } catch (std::exception& e) {
36772       {
36773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36774       };
36775     } catch (...) {
36776       {
36777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36778       };
36779     }
36780   }
36781   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36782   return jresult;
36783 }
36784
36785
36786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36787   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36788
36789   arg1 = (Dali::TapGestureDetector *)jarg1;
36790   {
36791     try {
36792       delete arg1;
36793     } catch (std::out_of_range& e) {
36794       {
36795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36796       };
36797     } catch (std::exception& e) {
36798       {
36799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36800       };
36801     } catch (...) {
36802       {
36803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36804       };
36805     }
36806   }
36807 }
36808
36809
36810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36811   void * jresult ;
36812   Dali::TapGestureDetector *arg1 = 0 ;
36813   Dali::TapGestureDetector *result = 0 ;
36814
36815   arg1 = (Dali::TapGestureDetector *)jarg1;
36816   if (!arg1) {
36817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36818     return 0;
36819   }
36820   {
36821     try {
36822       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36823     } catch (std::out_of_range& e) {
36824       {
36825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36826       };
36827     } catch (std::exception& e) {
36828       {
36829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36830       };
36831     } catch (...) {
36832       {
36833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36834       };
36835     }
36836   }
36837   jresult = (void *)result;
36838   return jresult;
36839 }
36840
36841
36842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
36843   void * jresult ;
36844   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36845   Dali::TapGestureDetector *arg2 = 0 ;
36846   Dali::TapGestureDetector *result = 0 ;
36847
36848   arg1 = (Dali::TapGestureDetector *)jarg1;
36849   arg2 = (Dali::TapGestureDetector *)jarg2;
36850   if (!arg2) {
36851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36852     return 0;
36853   }
36854   {
36855     try {
36856       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
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 (...) {
36866       {
36867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36868       };
36869     }
36870   }
36871   jresult = (void *)result;
36872   return jresult;
36873 }
36874
36875
36876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
36877   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36878   unsigned int arg2 ;
36879
36880   arg1 = (Dali::TapGestureDetector *)jarg1;
36881   arg2 = (unsigned int)jarg2;
36882   {
36883     try {
36884       (arg1)->SetMinimumTapsRequired(arg2);
36885     } catch (std::out_of_range& e) {
36886       {
36887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36888       };
36889     } catch (std::exception& e) {
36890       {
36891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36892       };
36893     } catch (...) {
36894       {
36895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36896       };
36897     }
36898   }
36899 }
36900
36901
36902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
36903   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36904   unsigned int arg2 ;
36905
36906   arg1 = (Dali::TapGestureDetector *)jarg1;
36907   arg2 = (unsigned int)jarg2;
36908   {
36909     try {
36910       (arg1)->SetMaximumTapsRequired(arg2);
36911     } catch (std::out_of_range& e) {
36912       {
36913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36914       };
36915     } catch (std::exception& e) {
36916       {
36917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36918       };
36919     } catch (...) {
36920       {
36921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36922       };
36923     }
36924   }
36925 }
36926
36927
36928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
36929   unsigned int jresult ;
36930   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36931   unsigned int result;
36932
36933   arg1 = (Dali::TapGestureDetector *)jarg1;
36934   {
36935     try {
36936       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
36937     } catch (std::out_of_range& e) {
36938       {
36939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36940       };
36941     } catch (std::exception& e) {
36942       {
36943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36944       };
36945     } catch (...) {
36946       {
36947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36948       };
36949     }
36950   }
36951   jresult = result;
36952   return jresult;
36953 }
36954
36955
36956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
36957   unsigned int jresult ;
36958   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36959   unsigned int result;
36960
36961   arg1 = (Dali::TapGestureDetector *)jarg1;
36962   {
36963     try {
36964       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
36965     } catch (std::out_of_range& e) {
36966       {
36967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36968       };
36969     } catch (std::exception& e) {
36970       {
36971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36972       };
36973     } catch (...) {
36974       {
36975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36976       };
36977     }
36978   }
36979   jresult = result;
36980   return jresult;
36981 }
36982
36983
36984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
36985   void * jresult ;
36986   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36987   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
36988
36989   arg1 = (Dali::TapGestureDetector *)jarg1;
36990   {
36991     try {
36992       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36993     } catch (std::out_of_range& e) {
36994       {
36995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36996       };
36997     } catch (std::exception& e) {
36998       {
36999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37000       };
37001     } catch (...) {
37002       {
37003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37004       };
37005     }
37006   }
37007   jresult = (void *)result;
37008   return jresult;
37009 }
37010
37011
37012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37013   void * jresult ;
37014   Dali::TapGesture *result = 0 ;
37015
37016   {
37017     try {
37018       result = (Dali::TapGesture *)new Dali::TapGesture();
37019     } catch (std::out_of_range& e) {
37020       {
37021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37022       };
37023     } catch (std::exception& e) {
37024       {
37025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37026       };
37027     } catch (...) {
37028       {
37029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37030       };
37031     }
37032   }
37033   jresult = (void *)result;
37034   return jresult;
37035 }
37036
37037
37038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37039   void * jresult ;
37040   Dali::TapGesture *arg1 = 0 ;
37041   Dali::TapGesture *result = 0 ;
37042
37043   arg1 = (Dali::TapGesture *)jarg1;
37044   if (!arg1) {
37045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37046     return 0;
37047   }
37048   {
37049     try {
37050       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37051     } catch (std::out_of_range& e) {
37052       {
37053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37054       };
37055     } catch (std::exception& e) {
37056       {
37057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37058       };
37059     } catch (...) {
37060       {
37061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37062       };
37063     }
37064   }
37065   jresult = (void *)result;
37066   return jresult;
37067 }
37068
37069
37070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37071   void * jresult ;
37072   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37073   Dali::TapGesture *arg2 = 0 ;
37074   Dali::TapGesture *result = 0 ;
37075
37076   arg1 = (Dali::TapGesture *)jarg1;
37077   arg2 = (Dali::TapGesture *)jarg2;
37078   if (!arg2) {
37079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37080     return 0;
37081   }
37082   {
37083     try {
37084       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37085     } catch (std::out_of_range& e) {
37086       {
37087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37088       };
37089     } catch (std::exception& e) {
37090       {
37091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37092       };
37093     } catch (...) {
37094       {
37095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37096       };
37097     }
37098   }
37099   jresult = (void *)result;
37100   return jresult;
37101 }
37102
37103
37104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37105   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37106
37107   arg1 = (Dali::TapGesture *)jarg1;
37108   {
37109     try {
37110       delete arg1;
37111     } catch (std::out_of_range& e) {
37112       {
37113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37114       };
37115     } catch (std::exception& e) {
37116       {
37117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37118       };
37119     } catch (...) {
37120       {
37121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37122       };
37123     }
37124   }
37125 }
37126
37127
37128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37129   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37130   unsigned int arg2 ;
37131
37132   arg1 = (Dali::TapGesture *)jarg1;
37133   arg2 = (unsigned int)jarg2;
37134   if (arg1) (arg1)->numberOfTaps = arg2;
37135 }
37136
37137
37138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37139   unsigned int jresult ;
37140   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37141   unsigned int result;
37142
37143   arg1 = (Dali::TapGesture *)jarg1;
37144   result = (unsigned int) ((arg1)->numberOfTaps);
37145   jresult = result;
37146   return jresult;
37147 }
37148
37149
37150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37151   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37152   unsigned int arg2 ;
37153
37154   arg1 = (Dali::TapGesture *)jarg1;
37155   arg2 = (unsigned int)jarg2;
37156   if (arg1) (arg1)->numberOfTouches = arg2;
37157 }
37158
37159
37160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37161   unsigned int jresult ;
37162   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37163   unsigned int result;
37164
37165   arg1 = (Dali::TapGesture *)jarg1;
37166   result = (unsigned int) ((arg1)->numberOfTouches);
37167   jresult = result;
37168   return jresult;
37169 }
37170
37171
37172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37173   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37174   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37175
37176   arg1 = (Dali::TapGesture *)jarg1;
37177   arg2 = (Dali::Vector2 *)jarg2;
37178   if (arg1) (arg1)->screenPoint = *arg2;
37179 }
37180
37181
37182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37183   void * jresult ;
37184   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37185   Dali::Vector2 *result = 0 ;
37186
37187   arg1 = (Dali::TapGesture *)jarg1;
37188   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37189   jresult = (void *)result;
37190   return jresult;
37191 }
37192
37193
37194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37195   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37196   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37197
37198   arg1 = (Dali::TapGesture *)jarg1;
37199   arg2 = (Dali::Vector2 *)jarg2;
37200   if (arg1) (arg1)->localPoint = *arg2;
37201 }
37202
37203
37204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37205   void * jresult ;
37206   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37207   Dali::Vector2 *result = 0 ;
37208
37209   arg1 = (Dali::TapGesture *)jarg1;
37210   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37211   jresult = (void *)result;
37212   return jresult;
37213 }
37214
37215
37216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37217   void * jresult ;
37218   Dali::AlphaFunction *result = 0 ;
37219
37220   {
37221     try {
37222       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37223     } catch (std::out_of_range& e) {
37224       {
37225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37226       };
37227     } catch (std::exception& e) {
37228       {
37229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37230       };
37231     } catch (...) {
37232       {
37233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37234       };
37235     }
37236   }
37237   jresult = (void *)result;
37238   return jresult;
37239 }
37240
37241
37242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37243   void * jresult ;
37244   Dali::AlphaFunction::BuiltinFunction arg1 ;
37245   Dali::AlphaFunction *result = 0 ;
37246
37247   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37248   {
37249     try {
37250       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37251     } catch (std::out_of_range& e) {
37252       {
37253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37254       };
37255     } catch (std::exception& e) {
37256       {
37257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37258       };
37259     } catch (...) {
37260       {
37261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37262       };
37263     }
37264   }
37265   jresult = (void *)result;
37266   return jresult;
37267 }
37268
37269
37270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37271   void * jresult ;
37272   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37273   Dali::AlphaFunction *result = 0 ;
37274
37275   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37276   {
37277     try {
37278       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37279     } catch (std::out_of_range& e) {
37280       {
37281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37282       };
37283     } catch (std::exception& e) {
37284       {
37285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37286       };
37287     } catch (...) {
37288       {
37289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37290       };
37291     }
37292   }
37293   jresult = (void *)result;
37294   return jresult;
37295 }
37296
37297
37298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37299   void * jresult ;
37300   Dali::Vector2 *arg1 = 0 ;
37301   Dali::Vector2 *arg2 = 0 ;
37302   Dali::AlphaFunction *result = 0 ;
37303
37304   arg1 = (Dali::Vector2 *)jarg1;
37305   if (!arg1) {
37306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37307     return 0;
37308   }
37309   arg2 = (Dali::Vector2 *)jarg2;
37310   if (!arg2) {
37311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37312     return 0;
37313   }
37314   {
37315     try {
37316       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37317     } catch (std::out_of_range& e) {
37318       {
37319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37320       };
37321     } catch (std::exception& e) {
37322       {
37323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37324       };
37325     } catch (...) {
37326       {
37327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37328       };
37329     }
37330   }
37331   jresult = (void *)result;
37332   return jresult;
37333 }
37334
37335
37336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37337   void * jresult ;
37338   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37339   Dali::Vector4 result;
37340
37341   arg1 = (Dali::AlphaFunction *)jarg1;
37342   {
37343     try {
37344       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37345     } catch (std::out_of_range& e) {
37346       {
37347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37348       };
37349     } catch (std::exception& e) {
37350       {
37351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37352       };
37353     } catch (...) {
37354       {
37355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37356       };
37357     }
37358   }
37359   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37360   return jresult;
37361 }
37362
37363
37364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37365   void * jresult ;
37366   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37367   Dali::AlphaFunctionPrototype result;
37368
37369   arg1 = (Dali::AlphaFunction *)jarg1;
37370   {
37371     try {
37372       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37373     } catch (std::out_of_range& e) {
37374       {
37375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37376       };
37377     } catch (std::exception& e) {
37378       {
37379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37380       };
37381     } catch (...) {
37382       {
37383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37384       };
37385     }
37386   }
37387   jresult = (void *)result;
37388   return jresult;
37389 }
37390
37391
37392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37393   int jresult ;
37394   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37395   Dali::AlphaFunction::BuiltinFunction result;
37396
37397   arg1 = (Dali::AlphaFunction *)jarg1;
37398   {
37399     try {
37400       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37401     } catch (std::out_of_range& e) {
37402       {
37403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37404       };
37405     } catch (std::exception& e) {
37406       {
37407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37408       };
37409     } catch (...) {
37410       {
37411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37412       };
37413     }
37414   }
37415   jresult = (int)result;
37416   return jresult;
37417 }
37418
37419
37420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37421   int jresult ;
37422   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37423   Dali::AlphaFunction::Mode result;
37424
37425   arg1 = (Dali::AlphaFunction *)jarg1;
37426   {
37427     try {
37428       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37429     } catch (std::out_of_range& e) {
37430       {
37431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37432       };
37433     } catch (std::exception& e) {
37434       {
37435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37436       };
37437     } catch (...) {
37438       {
37439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37440       };
37441     }
37442   }
37443   jresult = (int)result;
37444   return jresult;
37445 }
37446
37447
37448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37449   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37450
37451   arg1 = (Dali::AlphaFunction *)jarg1;
37452   {
37453     try {
37454       delete arg1;
37455     } catch (std::out_of_range& e) {
37456       {
37457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37458       };
37459     } catch (std::exception& e) {
37460       {
37461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37462       };
37463     } catch (...) {
37464       {
37465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37466       };
37467     }
37468   }
37469 }
37470
37471
37472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37473   void * jresult ;
37474   Dali::KeyFrames result;
37475
37476   {
37477     try {
37478       result = Dali::KeyFrames::New();
37479     } catch (std::out_of_range& e) {
37480       {
37481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37482       };
37483     } catch (std::exception& e) {
37484       {
37485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37486       };
37487     } catch (...) {
37488       {
37489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37490       };
37491     }
37492   }
37493   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37494   return jresult;
37495 }
37496
37497
37498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37499   void * jresult ;
37500   Dali::BaseHandle arg1 ;
37501   Dali::BaseHandle *argp1 ;
37502   Dali::KeyFrames result;
37503
37504   argp1 = (Dali::BaseHandle *)jarg1;
37505   if (!argp1) {
37506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37507     return 0;
37508   }
37509   arg1 = *argp1;
37510   {
37511     try {
37512       result = Dali::KeyFrames::DownCast(arg1);
37513     } catch (std::out_of_range& e) {
37514       {
37515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37516       };
37517     } catch (std::exception& e) {
37518       {
37519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37520       };
37521     } catch (...) {
37522       {
37523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37524       };
37525     }
37526   }
37527   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37528   return jresult;
37529 }
37530
37531
37532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37533   void * jresult ;
37534   Dali::KeyFrames *result = 0 ;
37535
37536   {
37537     try {
37538       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37539     } catch (std::out_of_range& e) {
37540       {
37541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37542       };
37543     } catch (std::exception& e) {
37544       {
37545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37546       };
37547     } catch (...) {
37548       {
37549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37550       };
37551     }
37552   }
37553   jresult = (void *)result;
37554   return jresult;
37555 }
37556
37557
37558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37559   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37560
37561   arg1 = (Dali::KeyFrames *)jarg1;
37562   {
37563     try {
37564       delete arg1;
37565     } catch (std::out_of_range& e) {
37566       {
37567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37568       };
37569     } catch (std::exception& e) {
37570       {
37571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37572       };
37573     } catch (...) {
37574       {
37575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37576       };
37577     }
37578   }
37579 }
37580
37581
37582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37583   void * jresult ;
37584   Dali::KeyFrames *arg1 = 0 ;
37585   Dali::KeyFrames *result = 0 ;
37586
37587   arg1 = (Dali::KeyFrames *)jarg1;
37588   if (!arg1) {
37589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37590     return 0;
37591   }
37592   {
37593     try {
37594       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37595     } catch (std::out_of_range& e) {
37596       {
37597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37598       };
37599     } catch (std::exception& e) {
37600       {
37601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37602       };
37603     } catch (...) {
37604       {
37605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37606       };
37607     }
37608   }
37609   jresult = (void *)result;
37610   return jresult;
37611 }
37612
37613
37614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37615   void * jresult ;
37616   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37617   Dali::KeyFrames *arg2 = 0 ;
37618   Dali::KeyFrames *result = 0 ;
37619
37620   arg1 = (Dali::KeyFrames *)jarg1;
37621   arg2 = (Dali::KeyFrames *)jarg2;
37622   if (!arg2) {
37623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37624     return 0;
37625   }
37626   {
37627     try {
37628       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37629     } catch (std::out_of_range& e) {
37630       {
37631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37632       };
37633     } catch (std::exception& e) {
37634       {
37635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37636       };
37637     } catch (...) {
37638       {
37639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37640       };
37641     }
37642   }
37643   jresult = (void *)result;
37644   return jresult;
37645 }
37646
37647
37648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37649   int jresult ;
37650   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37651   Dali::Property::Type result;
37652
37653   arg1 = (Dali::KeyFrames *)jarg1;
37654   {
37655     try {
37656       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37657     } catch (std::out_of_range& e) {
37658       {
37659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37660       };
37661     } catch (std::exception& e) {
37662       {
37663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37664       };
37665     } catch (...) {
37666       {
37667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37668       };
37669     }
37670   }
37671   jresult = (int)result;
37672   return jresult;
37673 }
37674
37675
37676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37677   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37678   float arg2 ;
37679   Dali::Property::Value arg3 ;
37680   Dali::Property::Value *argp3 ;
37681
37682   arg1 = (Dali::KeyFrames *)jarg1;
37683   arg2 = (float)jarg2;
37684   argp3 = (Dali::Property::Value *)jarg3;
37685   if (!argp3) {
37686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37687     return ;
37688   }
37689   arg3 = *argp3;
37690   {
37691     try {
37692       (arg1)->Add(arg2,arg3);
37693     } catch (std::out_of_range& e) {
37694       {
37695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37696       };
37697     } catch (std::exception& e) {
37698       {
37699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37700       };
37701     } catch (...) {
37702       {
37703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37704       };
37705     }
37706   }
37707 }
37708
37709
37710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37711   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37712   float arg2 ;
37713   Dali::Property::Value arg3 ;
37714   Dali::AlphaFunction arg4 ;
37715   Dali::Property::Value *argp3 ;
37716   Dali::AlphaFunction *argp4 ;
37717
37718   arg1 = (Dali::KeyFrames *)jarg1;
37719   arg2 = (float)jarg2;
37720   argp3 = (Dali::Property::Value *)jarg3;
37721   if (!argp3) {
37722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37723     return ;
37724   }
37725   arg3 = *argp3;
37726   argp4 = (Dali::AlphaFunction *)jarg4;
37727   if (!argp4) {
37728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37729     return ;
37730   }
37731   arg4 = *argp4;
37732   {
37733     try {
37734       (arg1)->Add(arg2,arg3,arg4);
37735     } catch (std::out_of_range& e) {
37736       {
37737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37738       };
37739     } catch (std::exception& e) {
37740       {
37741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37742       };
37743     } catch (...) {
37744       {
37745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37746       };
37747     }
37748   }
37749 }
37750
37751
37752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37753   int jresult ;
37754   int result;
37755
37756   result = (int)Dali::Path::Property::POINTS;
37757   jresult = (int)result;
37758   return jresult;
37759 }
37760
37761
37762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37763   int jresult ;
37764   int result;
37765
37766   result = (int)Dali::Path::Property::CONTROL_POINTS;
37767   jresult = (int)result;
37768   return jresult;
37769 }
37770
37771
37772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37773   void * jresult ;
37774   Dali::Path::Property *result = 0 ;
37775
37776   {
37777     try {
37778       result = (Dali::Path::Property *)new Dali::Path::Property();
37779     } catch (std::out_of_range& e) {
37780       {
37781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37782       };
37783     } catch (std::exception& e) {
37784       {
37785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37786       };
37787     } catch (...) {
37788       {
37789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37790       };
37791     }
37792   }
37793   jresult = (void *)result;
37794   return jresult;
37795 }
37796
37797
37798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37799   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37800
37801   arg1 = (Dali::Path::Property *)jarg1;
37802   {
37803     try {
37804       delete arg1;
37805     } catch (std::out_of_range& e) {
37806       {
37807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37808       };
37809     } catch (std::exception& e) {
37810       {
37811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37812       };
37813     } catch (...) {
37814       {
37815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37816       };
37817     }
37818   }
37819 }
37820
37821
37822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37823   void * jresult ;
37824   Dali::Path result;
37825
37826   {
37827     try {
37828       result = Dali::Path::New();
37829     } catch (std::out_of_range& e) {
37830       {
37831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37832       };
37833     } catch (std::exception& e) {
37834       {
37835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37836       };
37837     } catch (...) {
37838       {
37839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37840       };
37841     }
37842   }
37843   jresult = new Dali::Path((const Dali::Path &)result);
37844   return jresult;
37845 }
37846
37847
37848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
37849   void * jresult ;
37850   Dali::BaseHandle arg1 ;
37851   Dali::BaseHandle *argp1 ;
37852   Dali::Path result;
37853
37854   argp1 = (Dali::BaseHandle *)jarg1;
37855   if (!argp1) {
37856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37857     return 0;
37858   }
37859   arg1 = *argp1;
37860   {
37861     try {
37862       result = Dali::Path::DownCast(arg1);
37863     } catch (std::out_of_range& e) {
37864       {
37865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37866       };
37867     } catch (std::exception& e) {
37868       {
37869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37870       };
37871     } catch (...) {
37872       {
37873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37874       };
37875     }
37876   }
37877   jresult = new Dali::Path((const Dali::Path &)result);
37878   return jresult;
37879 }
37880
37881
37882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
37883   void * jresult ;
37884   Dali::Path *result = 0 ;
37885
37886   {
37887     try {
37888       result = (Dali::Path *)new Dali::Path();
37889     } catch (std::out_of_range& e) {
37890       {
37891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37892       };
37893     } catch (std::exception& e) {
37894       {
37895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37896       };
37897     } catch (...) {
37898       {
37899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37900       };
37901     }
37902   }
37903   jresult = (void *)result;
37904   return jresult;
37905 }
37906
37907
37908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
37909   Dali::Path *arg1 = (Dali::Path *) 0 ;
37910
37911   arg1 = (Dali::Path *)jarg1;
37912   {
37913     try {
37914       delete arg1;
37915     } catch (std::out_of_range& e) {
37916       {
37917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37918       };
37919     } catch (std::exception& e) {
37920       {
37921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37922       };
37923     } catch (...) {
37924       {
37925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37926       };
37927     }
37928   }
37929 }
37930
37931
37932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
37933   void * jresult ;
37934   Dali::Path *arg1 = 0 ;
37935   Dali::Path *result = 0 ;
37936
37937   arg1 = (Dali::Path *)jarg1;
37938   if (!arg1) {
37939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37940     return 0;
37941   }
37942   {
37943     try {
37944       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
37945     } catch (std::out_of_range& e) {
37946       {
37947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37948       };
37949     } catch (std::exception& e) {
37950       {
37951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37952       };
37953     } catch (...) {
37954       {
37955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37956       };
37957     }
37958   }
37959   jresult = (void *)result;
37960   return jresult;
37961 }
37962
37963
37964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
37965   void * jresult ;
37966   Dali::Path *arg1 = (Dali::Path *) 0 ;
37967   Dali::Path *arg2 = 0 ;
37968   Dali::Path *result = 0 ;
37969
37970   arg1 = (Dali::Path *)jarg1;
37971   arg2 = (Dali::Path *)jarg2;
37972   if (!arg2) {
37973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
37974     return 0;
37975   }
37976   {
37977     try {
37978       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
37979     } catch (std::out_of_range& e) {
37980       {
37981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37982       };
37983     } catch (std::exception& e) {
37984       {
37985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37986       };
37987     } catch (...) {
37988       {
37989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37990       };
37991     }
37992   }
37993   jresult = (void *)result;
37994   return jresult;
37995 }
37996
37997
37998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
37999   Dali::Path *arg1 = (Dali::Path *) 0 ;
38000   Dali::Vector3 *arg2 = 0 ;
38001
38002   arg1 = (Dali::Path *)jarg1;
38003   arg2 = (Dali::Vector3 *)jarg2;
38004   if (!arg2) {
38005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38006     return ;
38007   }
38008   {
38009     try {
38010       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38011     } catch (std::out_of_range& e) {
38012       {
38013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38014       };
38015     } catch (std::exception& e) {
38016       {
38017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38018       };
38019     } catch (...) {
38020       {
38021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38022       };
38023     }
38024   }
38025 }
38026
38027
38028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38029   Dali::Path *arg1 = (Dali::Path *) 0 ;
38030   Dali::Vector3 *arg2 = 0 ;
38031
38032   arg1 = (Dali::Path *)jarg1;
38033   arg2 = (Dali::Vector3 *)jarg2;
38034   if (!arg2) {
38035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38036     return ;
38037   }
38038   {
38039     try {
38040       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38041     } catch (std::out_of_range& e) {
38042       {
38043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38044       };
38045     } catch (std::exception& e) {
38046       {
38047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38048       };
38049     } catch (...) {
38050       {
38051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38052       };
38053     }
38054   }
38055 }
38056
38057
38058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38059   Dali::Path *arg1 = (Dali::Path *) 0 ;
38060   float arg2 ;
38061
38062   arg1 = (Dali::Path *)jarg1;
38063   arg2 = (float)jarg2;
38064   {
38065     try {
38066       (arg1)->GenerateControlPoints(arg2);
38067     } catch (std::out_of_range& e) {
38068       {
38069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38070       };
38071     } catch (std::exception& e) {
38072       {
38073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38074       };
38075     } catch (...) {
38076       {
38077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38078       };
38079     }
38080   }
38081 }
38082
38083
38084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38085   Dali::Path *arg1 = (Dali::Path *) 0 ;
38086   float arg2 ;
38087   Dali::Vector3 *arg3 = 0 ;
38088   Dali::Vector3 *arg4 = 0 ;
38089
38090   arg1 = (Dali::Path *)jarg1;
38091   arg2 = (float)jarg2;
38092   arg3 = (Dali::Vector3 *)jarg3;
38093   if (!arg3) {
38094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38095     return ;
38096   }
38097   arg4 = (Dali::Vector3 *)jarg4;
38098   if (!arg4) {
38099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38100     return ;
38101   }
38102   {
38103     try {
38104       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38105     } catch (std::out_of_range& e) {
38106       {
38107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38108       };
38109     } catch (std::exception& e) {
38110       {
38111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38112       };
38113     } catch (...) {
38114       {
38115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38116       };
38117     }
38118   }
38119 }
38120
38121
38122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38123   void * jresult ;
38124   Dali::Path *arg1 = (Dali::Path *) 0 ;
38125   size_t arg2 ;
38126   Dali::Vector3 *result = 0 ;
38127
38128   arg1 = (Dali::Path *)jarg1;
38129   arg2 = (size_t)jarg2;
38130   {
38131     try {
38132       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38133     } catch (std::out_of_range& e) {
38134       {
38135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38136       };
38137     } catch (std::exception& e) {
38138       {
38139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38140       };
38141     } catch (...) {
38142       {
38143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38144       };
38145     }
38146   }
38147   jresult = (void *)result;
38148   return jresult;
38149 }
38150
38151
38152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38153   void * jresult ;
38154   Dali::Path *arg1 = (Dali::Path *) 0 ;
38155   size_t arg2 ;
38156   Dali::Vector3 *result = 0 ;
38157
38158   arg1 = (Dali::Path *)jarg1;
38159   arg2 = (size_t)jarg2;
38160   {
38161     try {
38162       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38163     } catch (std::out_of_range& e) {
38164       {
38165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38166       };
38167     } catch (std::exception& e) {
38168       {
38169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38170       };
38171     } catch (...) {
38172       {
38173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38174       };
38175     }
38176   }
38177   jresult = (void *)result;
38178   return jresult;
38179 }
38180
38181
38182 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38183   unsigned long jresult ;
38184   Dali::Path *arg1 = (Dali::Path *) 0 ;
38185   size_t result;
38186
38187   arg1 = (Dali::Path *)jarg1;
38188   {
38189     try {
38190       result = ((Dali::Path const *)arg1)->GetPointCount();
38191     } catch (std::out_of_range& e) {
38192       {
38193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38194       };
38195     } catch (std::exception& e) {
38196       {
38197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38198       };
38199     } catch (...) {
38200       {
38201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38202       };
38203     }
38204   }
38205   jresult = (unsigned long)result;
38206   return jresult;
38207 }
38208
38209
38210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38211   void * jresult ;
38212   float arg1 ;
38213   Dali::TimePeriod *result = 0 ;
38214
38215   arg1 = (float)jarg1;
38216   {
38217     try {
38218       result = (Dali::TimePeriod *)new Dali::TimePeriod(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 (...) {
38228       {
38229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38230       };
38231     }
38232   }
38233   jresult = (void *)result;
38234   return jresult;
38235 }
38236
38237
38238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38239   void * jresult ;
38240   float arg1 ;
38241   float arg2 ;
38242   Dali::TimePeriod *result = 0 ;
38243
38244   arg1 = (float)jarg1;
38245   arg2 = (float)jarg2;
38246   {
38247     try {
38248       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38249     } catch (std::out_of_range& e) {
38250       {
38251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38252       };
38253     } catch (std::exception& e) {
38254       {
38255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38256       };
38257     } catch (...) {
38258       {
38259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38260       };
38261     }
38262   }
38263   jresult = (void *)result;
38264   return jresult;
38265 }
38266
38267
38268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38269   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38270
38271   arg1 = (Dali::TimePeriod *)jarg1;
38272   {
38273     try {
38274       delete arg1;
38275     } catch (std::out_of_range& e) {
38276       {
38277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38278       };
38279     } catch (std::exception& e) {
38280       {
38281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38282       };
38283     } catch (...) {
38284       {
38285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38286       };
38287     }
38288   }
38289 }
38290
38291
38292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38293   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38294   float arg2 ;
38295
38296   arg1 = (Dali::TimePeriod *)jarg1;
38297   arg2 = (float)jarg2;
38298   if (arg1) (arg1)->delaySeconds = arg2;
38299 }
38300
38301
38302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38303   float jresult ;
38304   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38305   float result;
38306
38307   arg1 = (Dali::TimePeriod *)jarg1;
38308   result = (float) ((arg1)->delaySeconds);
38309   jresult = result;
38310   return jresult;
38311 }
38312
38313
38314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38315   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38316   float arg2 ;
38317
38318   arg1 = (Dali::TimePeriod *)jarg1;
38319   arg2 = (float)jarg2;
38320   if (arg1) (arg1)->durationSeconds = arg2;
38321 }
38322
38323
38324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38325   float jresult ;
38326   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38327   float result;
38328
38329   arg1 = (Dali::TimePeriod *)jarg1;
38330   result = (float) ((arg1)->durationSeconds);
38331   jresult = result;
38332   return jresult;
38333 }
38334
38335
38336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38337   void * jresult ;
38338   Dali::Animation *result = 0 ;
38339
38340   {
38341     try {
38342       result = (Dali::Animation *)new Dali::Animation();
38343     } catch (std::out_of_range& e) {
38344       {
38345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38346       };
38347     } catch (std::exception& e) {
38348       {
38349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38350       };
38351     } catch (...) {
38352       {
38353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38354       };
38355     }
38356   }
38357   jresult = (void *)result;
38358   return jresult;
38359 }
38360
38361
38362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38363   void * jresult ;
38364   float arg1 ;
38365   Dali::Animation result;
38366
38367   arg1 = (float)jarg1;
38368   {
38369     try {
38370       result = Dali::Animation::New(arg1);
38371     } catch (std::out_of_range& e) {
38372       {
38373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38374       };
38375     } catch (std::exception& e) {
38376       {
38377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38378       };
38379     } catch (...) {
38380       {
38381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38382       };
38383     }
38384   }
38385   jresult = new Dali::Animation((const Dali::Animation &)result);
38386   return jresult;
38387 }
38388
38389
38390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38391   void * jresult ;
38392   Dali::BaseHandle arg1 ;
38393   Dali::BaseHandle *argp1 ;
38394   Dali::Animation result;
38395
38396   argp1 = (Dali::BaseHandle *)jarg1;
38397   if (!argp1) {
38398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38399     return 0;
38400   }
38401   arg1 = *argp1;
38402   {
38403     try {
38404       result = Dali::Animation::DownCast(arg1);
38405     } catch (std::out_of_range& e) {
38406       {
38407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38408       };
38409     } catch (std::exception& e) {
38410       {
38411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38412       };
38413     } catch (...) {
38414       {
38415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38416       };
38417     }
38418   }
38419   jresult = new Dali::Animation((const Dali::Animation &)result);
38420   return jresult;
38421 }
38422
38423
38424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38425   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38426
38427   arg1 = (Dali::Animation *)jarg1;
38428   {
38429     try {
38430       delete arg1;
38431     } catch (std::out_of_range& e) {
38432       {
38433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38434       };
38435     } catch (std::exception& e) {
38436       {
38437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38438       };
38439     } catch (...) {
38440       {
38441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38442       };
38443     }
38444   }
38445 }
38446
38447
38448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38449   void * jresult ;
38450   Dali::Animation *arg1 = 0 ;
38451   Dali::Animation *result = 0 ;
38452
38453   arg1 = (Dali::Animation *)jarg1;
38454   if (!arg1) {
38455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38456     return 0;
38457   }
38458   {
38459     try {
38460       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38461     } catch (std::out_of_range& e) {
38462       {
38463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38464       };
38465     } catch (std::exception& e) {
38466       {
38467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38468       };
38469     } catch (...) {
38470       {
38471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38472       };
38473     }
38474   }
38475   jresult = (void *)result;
38476   return jresult;
38477 }
38478
38479
38480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38481   void * jresult ;
38482   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38483   Dali::Animation *arg2 = 0 ;
38484   Dali::Animation *result = 0 ;
38485
38486   arg1 = (Dali::Animation *)jarg1;
38487   arg2 = (Dali::Animation *)jarg2;
38488   if (!arg2) {
38489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38490     return 0;
38491   }
38492   {
38493     try {
38494       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
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 (...) {
38504       {
38505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38506       };
38507     }
38508   }
38509   jresult = (void *)result;
38510   return jresult;
38511 }
38512
38513
38514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38515   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38516   float arg2 ;
38517
38518   arg1 = (Dali::Animation *)jarg1;
38519   arg2 = (float)jarg2;
38520   {
38521     try {
38522       (arg1)->SetDuration(arg2);
38523     } catch (std::out_of_range& e) {
38524       {
38525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38526       };
38527     } catch (std::exception& e) {
38528       {
38529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38530       };
38531     } catch (...) {
38532       {
38533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38534       };
38535     }
38536   }
38537 }
38538
38539
38540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38541   float jresult ;
38542   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38543   float result;
38544
38545   arg1 = (Dali::Animation *)jarg1;
38546   {
38547     try {
38548       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38549     } catch (std::out_of_range& e) {
38550       {
38551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38552       };
38553     } catch (std::exception& e) {
38554       {
38555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38556       };
38557     } catch (...) {
38558       {
38559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38560       };
38561     }
38562   }
38563   jresult = result;
38564   return jresult;
38565 }
38566
38567
38568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38569   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38570   bool arg2 ;
38571
38572   arg1 = (Dali::Animation *)jarg1;
38573   arg2 = jarg2 ? true : false;
38574   {
38575     try {
38576       (arg1)->SetLooping(arg2);
38577     } catch (std::out_of_range& e) {
38578       {
38579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38580       };
38581     } catch (std::exception& e) {
38582       {
38583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38584       };
38585     } catch (...) {
38586       {
38587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38588       };
38589     }
38590   }
38591 }
38592
38593
38594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38595   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38596   int arg2 ;
38597
38598   arg1 = (Dali::Animation *)jarg1;
38599   arg2 = (int)jarg2;
38600   {
38601     try {
38602       (arg1)->SetLoopCount(arg2);
38603     } catch (std::out_of_range& e) {
38604       {
38605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38606       };
38607     } catch (std::exception& e) {
38608       {
38609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38610       };
38611     } catch (...) {
38612       {
38613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38614       };
38615     }
38616   }
38617 }
38618
38619
38620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38621   int jresult ;
38622   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38623   int result;
38624
38625   arg1 = (Dali::Animation *)jarg1;
38626   {
38627     try {
38628       result = (int)(arg1)->GetLoopCount();
38629     } catch (std::out_of_range& e) {
38630       {
38631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38632       };
38633     } catch (std::exception& e) {
38634       {
38635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38636       };
38637     } catch (...) {
38638       {
38639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38640       };
38641     }
38642   }
38643   jresult = result;
38644   return jresult;
38645 }
38646
38647
38648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38649   int jresult ;
38650   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38651   int result;
38652
38653   arg1 = (Dali::Animation *)jarg1;
38654   {
38655     try {
38656       result = (int)(arg1)->GetCurrentLoop();
38657     } catch (std::out_of_range& e) {
38658       {
38659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38660       };
38661     } catch (std::exception& e) {
38662       {
38663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38664       };
38665     } catch (...) {
38666       {
38667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38668       };
38669     }
38670   }
38671   jresult = result;
38672   return jresult;
38673 }
38674
38675
38676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38677   unsigned int jresult ;
38678   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38679   bool result;
38680
38681   arg1 = (Dali::Animation *)jarg1;
38682   {
38683     try {
38684       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38685     } catch (std::out_of_range& e) {
38686       {
38687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38688       };
38689     } catch (std::exception& e) {
38690       {
38691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38692       };
38693     } catch (...) {
38694       {
38695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38696       };
38697     }
38698   }
38699   jresult = result;
38700   return jresult;
38701 }
38702
38703
38704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38705   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38706   Dali::Animation::EndAction arg2 ;
38707
38708   arg1 = (Dali::Animation *)jarg1;
38709   arg2 = (Dali::Animation::EndAction)jarg2;
38710   {
38711     try {
38712       (arg1)->SetEndAction(arg2);
38713     } catch (std::out_of_range& e) {
38714       {
38715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38716       };
38717     } catch (std::exception& e) {
38718       {
38719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38720       };
38721     } catch (...) {
38722       {
38723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38724       };
38725     }
38726   }
38727 }
38728
38729
38730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38731   int jresult ;
38732   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38733   Dali::Animation::EndAction result;
38734
38735   arg1 = (Dali::Animation *)jarg1;
38736   {
38737     try {
38738       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38739     } catch (std::out_of_range& e) {
38740       {
38741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38742       };
38743     } catch (std::exception& e) {
38744       {
38745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38746       };
38747     } catch (...) {
38748       {
38749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38750       };
38751     }
38752   }
38753   jresult = (int)result;
38754   return jresult;
38755 }
38756
38757
38758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38759   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38760   Dali::Animation::EndAction arg2 ;
38761
38762   arg1 = (Dali::Animation *)jarg1;
38763   arg2 = (Dali::Animation::EndAction)jarg2;
38764   {
38765     try {
38766       (arg1)->SetDisconnectAction(arg2);
38767     } catch (std::out_of_range& e) {
38768       {
38769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38770       };
38771     } catch (std::exception& e) {
38772       {
38773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38774       };
38775     } catch (...) {
38776       {
38777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38778       };
38779     }
38780   }
38781 }
38782
38783
38784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38785   int jresult ;
38786   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38787   Dali::Animation::EndAction result;
38788
38789   arg1 = (Dali::Animation *)jarg1;
38790   {
38791     try {
38792       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38793     } catch (std::out_of_range& e) {
38794       {
38795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38796       };
38797     } catch (std::exception& e) {
38798       {
38799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38800       };
38801     } catch (...) {
38802       {
38803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38804       };
38805     }
38806   }
38807   jresult = (int)result;
38808   return jresult;
38809 }
38810
38811
38812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38813   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38814   Dali::AlphaFunction arg2 ;
38815   Dali::AlphaFunction *argp2 ;
38816
38817   arg1 = (Dali::Animation *)jarg1;
38818   argp2 = (Dali::AlphaFunction *)jarg2;
38819   if (!argp2) {
38820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38821     return ;
38822   }
38823   arg2 = *argp2;
38824   {
38825     try {
38826       (arg1)->SetDefaultAlphaFunction(arg2);
38827     } catch (std::out_of_range& e) {
38828       {
38829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38830       };
38831     } catch (std::exception& e) {
38832       {
38833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38834       };
38835     } catch (...) {
38836       {
38837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38838       };
38839     }
38840   }
38841 }
38842
38843
38844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
38845   void * jresult ;
38846   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38847   Dali::AlphaFunction result;
38848
38849   arg1 = (Dali::Animation *)jarg1;
38850   {
38851     try {
38852       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
38853     } catch (std::out_of_range& e) {
38854       {
38855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38856       };
38857     } catch (std::exception& e) {
38858       {
38859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38860       };
38861     } catch (...) {
38862       {
38863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38864       };
38865     }
38866   }
38867   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
38868   return jresult;
38869 }
38870
38871
38872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
38873   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38874   float arg2 ;
38875
38876   arg1 = (Dali::Animation *)jarg1;
38877   arg2 = (float)jarg2;
38878   {
38879     try {
38880       (arg1)->SetCurrentProgress(arg2);
38881     } catch (std::out_of_range& e) {
38882       {
38883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38884       };
38885     } catch (std::exception& e) {
38886       {
38887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38888       };
38889     } catch (...) {
38890       {
38891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38892       };
38893     }
38894   }
38895 }
38896
38897
38898 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
38899   float jresult ;
38900   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38901   float result;
38902
38903   arg1 = (Dali::Animation *)jarg1;
38904   {
38905     try {
38906       result = (float)(arg1)->GetCurrentProgress();
38907     } catch (std::out_of_range& e) {
38908       {
38909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38910       };
38911     } catch (std::exception& e) {
38912       {
38913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38914       };
38915     } catch (...) {
38916       {
38917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38918       };
38919     }
38920   }
38921   jresult = result;
38922   return jresult;
38923 }
38924
38925
38926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
38927   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38928   float arg2 ;
38929
38930   arg1 = (Dali::Animation *)jarg1;
38931   arg2 = (float)jarg2;
38932   {
38933     try {
38934       (arg1)->SetSpeedFactor(arg2);
38935     } catch (std::out_of_range& e) {
38936       {
38937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38938       };
38939     } catch (std::exception& e) {
38940       {
38941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38942       };
38943     } catch (...) {
38944       {
38945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38946       };
38947     }
38948   }
38949 }
38950
38951
38952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
38953   float jresult ;
38954   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38955   float result;
38956
38957   arg1 = (Dali::Animation *)jarg1;
38958   {
38959     try {
38960       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
38961     } catch (std::out_of_range& e) {
38962       {
38963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38964       };
38965     } catch (std::exception& e) {
38966       {
38967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38968       };
38969     } catch (...) {
38970       {
38971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38972       };
38973     }
38974   }
38975   jresult = result;
38976   return jresult;
38977 }
38978
38979
38980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
38981   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38982   Dali::Vector2 *arg2 = 0 ;
38983
38984   arg1 = (Dali::Animation *)jarg1;
38985   arg2 = (Dali::Vector2 *)jarg2;
38986   if (!arg2) {
38987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38988     return ;
38989   }
38990   {
38991     try {
38992       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
38993     } catch (std::out_of_range& e) {
38994       {
38995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38996       };
38997     } catch (std::exception& e) {
38998       {
38999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39000       };
39001     } catch (...) {
39002       {
39003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39004       };
39005     }
39006   }
39007 }
39008
39009
39010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39011   void * jresult ;
39012   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39013   Dali::Vector2 result;
39014
39015   arg1 = (Dali::Animation *)jarg1;
39016   {
39017     try {
39018       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39019     } catch (std::out_of_range& e) {
39020       {
39021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39022       };
39023     } catch (std::exception& e) {
39024       {
39025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39026       };
39027     } catch (...) {
39028       {
39029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39030       };
39031     }
39032   }
39033   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39034   return jresult;
39035 }
39036
39037
39038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39039   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39040
39041   arg1 = (Dali::Animation *)jarg1;
39042   {
39043     try {
39044       (arg1)->Play();
39045     } catch (std::out_of_range& e) {
39046       {
39047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39048       };
39049     } catch (std::exception& e) {
39050       {
39051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39052       };
39053     } catch (...) {
39054       {
39055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39056       };
39057     }
39058   }
39059 }
39060
39061
39062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39063   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39064   float arg2 ;
39065
39066   arg1 = (Dali::Animation *)jarg1;
39067   arg2 = (float)jarg2;
39068   {
39069     try {
39070       (arg1)->PlayFrom(arg2);
39071     } catch (std::out_of_range& e) {
39072       {
39073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39074       };
39075     } catch (std::exception& e) {
39076       {
39077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39078       };
39079     } catch (...) {
39080       {
39081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39082       };
39083     }
39084   }
39085 }
39086
39087
39088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39089   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39090
39091   arg1 = (Dali::Animation *)jarg1;
39092   {
39093     try {
39094       (arg1)->Pause();
39095     } catch (std::out_of_range& e) {
39096       {
39097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39098       };
39099     } catch (std::exception& e) {
39100       {
39101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39102       };
39103     } catch (...) {
39104       {
39105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39106       };
39107     }
39108   }
39109 }
39110
39111
39112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39113   int jresult ;
39114   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39115   Dali::Animation::State result;
39116
39117   arg1 = (Dali::Animation *)jarg1;
39118   {
39119     try {
39120       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39121     } catch (std::out_of_range& e) {
39122       {
39123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39124       };
39125     } catch (std::exception& e) {
39126       {
39127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39128       };
39129     } catch (...) {
39130       {
39131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39132       };
39133     }
39134   }
39135   jresult = (int)result;
39136   return jresult;
39137 }
39138
39139
39140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39141   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39142
39143   arg1 = (Dali::Animation *)jarg1;
39144   {
39145     try {
39146       (arg1)->Stop();
39147     } catch (std::out_of_range& e) {
39148       {
39149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39150       };
39151     } catch (std::exception& e) {
39152       {
39153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39154       };
39155     } catch (...) {
39156       {
39157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39158       };
39159     }
39160   }
39161 }
39162
39163
39164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39165   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39166
39167   arg1 = (Dali::Animation *)jarg1;
39168   {
39169     try {
39170       (arg1)->Clear();
39171     } catch (std::out_of_range& e) {
39172       {
39173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39174       };
39175     } catch (std::exception& e) {
39176       {
39177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39178       };
39179     } catch (...) {
39180       {
39181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39182       };
39183     }
39184   }
39185 }
39186
39187
39188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39189   void * jresult ;
39190   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39191   Dali::Animation::AnimationSignalType *result = 0 ;
39192
39193   arg1 = (Dali::Animation *)jarg1;
39194   {
39195     try {
39196       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39197     } catch (std::out_of_range& e) {
39198       {
39199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39200       };
39201     } catch (std::exception& e) {
39202       {
39203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39204       };
39205     } catch (...) {
39206       {
39207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39208       };
39209     }
39210   }
39211   jresult = (void *)result;
39212   return jresult;
39213 }
39214
39215
39216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39217   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39218   SwigValueWrapper< Dali::Property > arg2 ;
39219   Dali::Property::Value arg3 ;
39220   Dali::Property *argp2 ;
39221   Dali::Property::Value *argp3 ;
39222
39223   arg1 = (Dali::Animation *)jarg1;
39224   argp2 = (Dali::Property *)jarg2;
39225   if (!argp2) {
39226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39227     return ;
39228   }
39229   arg2 = *argp2;
39230   argp3 = (Dali::Property::Value *)jarg3;
39231   if (!argp3) {
39232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39233     return ;
39234   }
39235   arg3 = *argp3;
39236   {
39237     try {
39238       (arg1)->AnimateBy(arg2,arg3);
39239     } catch (std::out_of_range& e) {
39240       {
39241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39242       };
39243     } catch (std::exception& e) {
39244       {
39245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39246       };
39247     } catch (...) {
39248       {
39249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39250       };
39251     }
39252   }
39253 }
39254
39255
39256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39257   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39258   SwigValueWrapper< Dali::Property > arg2 ;
39259   Dali::Property::Value arg3 ;
39260   Dali::AlphaFunction arg4 ;
39261   Dali::Property *argp2 ;
39262   Dali::Property::Value *argp3 ;
39263   Dali::AlphaFunction *argp4 ;
39264
39265   arg1 = (Dali::Animation *)jarg1;
39266   argp2 = (Dali::Property *)jarg2;
39267   if (!argp2) {
39268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39269     return ;
39270   }
39271   arg2 = *argp2;
39272   argp3 = (Dali::Property::Value *)jarg3;
39273   if (!argp3) {
39274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39275     return ;
39276   }
39277   arg3 = *argp3;
39278   argp4 = (Dali::AlphaFunction *)jarg4;
39279   if (!argp4) {
39280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39281     return ;
39282   }
39283   arg4 = *argp4;
39284   {
39285     try {
39286       (arg1)->AnimateBy(arg2,arg3,arg4);
39287     } catch (std::out_of_range& e) {
39288       {
39289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39290       };
39291     } catch (std::exception& e) {
39292       {
39293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39294       };
39295     } catch (...) {
39296       {
39297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39298       };
39299     }
39300   }
39301 }
39302
39303
39304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39305   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39306   SwigValueWrapper< Dali::Property > arg2 ;
39307   Dali::Property::Value arg3 ;
39308   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39309   Dali::Property *argp2 ;
39310   Dali::Property::Value *argp3 ;
39311   Dali::TimePeriod *argp4 ;
39312
39313   arg1 = (Dali::Animation *)jarg1;
39314   argp2 = (Dali::Property *)jarg2;
39315   if (!argp2) {
39316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39317     return ;
39318   }
39319   arg2 = *argp2;
39320   argp3 = (Dali::Property::Value *)jarg3;
39321   if (!argp3) {
39322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39323     return ;
39324   }
39325   arg3 = *argp3;
39326   argp4 = (Dali::TimePeriod *)jarg4;
39327   if (!argp4) {
39328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39329     return ;
39330   }
39331   arg4 = *argp4;
39332   {
39333     try {
39334       (arg1)->AnimateBy(arg2,arg3,arg4);
39335     } catch (std::out_of_range& e) {
39336       {
39337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39338       };
39339     } catch (std::exception& e) {
39340       {
39341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39342       };
39343     } catch (...) {
39344       {
39345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39346       };
39347     }
39348   }
39349 }
39350
39351
39352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39353   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39354   SwigValueWrapper< Dali::Property > arg2 ;
39355   Dali::Property::Value arg3 ;
39356   Dali::AlphaFunction arg4 ;
39357   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39358   Dali::Property *argp2 ;
39359   Dali::Property::Value *argp3 ;
39360   Dali::AlphaFunction *argp4 ;
39361   Dali::TimePeriod *argp5 ;
39362
39363   arg1 = (Dali::Animation *)jarg1;
39364   argp2 = (Dali::Property *)jarg2;
39365   if (!argp2) {
39366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39367     return ;
39368   }
39369   arg2 = *argp2;
39370   argp3 = (Dali::Property::Value *)jarg3;
39371   if (!argp3) {
39372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39373     return ;
39374   }
39375   arg3 = *argp3;
39376   argp4 = (Dali::AlphaFunction *)jarg4;
39377   if (!argp4) {
39378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39379     return ;
39380   }
39381   arg4 = *argp4;
39382   argp5 = (Dali::TimePeriod *)jarg5;
39383   if (!argp5) {
39384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39385     return ;
39386   }
39387   arg5 = *argp5;
39388   {
39389     try {
39390       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39391     } catch (std::out_of_range& e) {
39392       {
39393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39394       };
39395     } catch (std::exception& e) {
39396       {
39397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39398       };
39399     } catch (...) {
39400       {
39401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39402       };
39403     }
39404   }
39405 }
39406
39407
39408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39409   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39410   SwigValueWrapper< Dali::Property > arg2 ;
39411   Dali::Property::Value arg3 ;
39412   Dali::Property *argp2 ;
39413   Dali::Property::Value *argp3 ;
39414
39415   arg1 = (Dali::Animation *)jarg1;
39416   argp2 = (Dali::Property *)jarg2;
39417   if (!argp2) {
39418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39419     return ;
39420   }
39421   arg2 = *argp2;
39422   argp3 = (Dali::Property::Value *)jarg3;
39423   if (!argp3) {
39424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39425     return ;
39426   }
39427   arg3 = *argp3;
39428   {
39429     try {
39430       (arg1)->AnimateTo(arg2,arg3);
39431     } catch (std::out_of_range& e) {
39432       {
39433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39434       };
39435     } catch (std::exception& e) {
39436       {
39437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39438       };
39439     } catch (...) {
39440       {
39441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39442       };
39443     }
39444   }
39445 }
39446
39447
39448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39449   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39450   SwigValueWrapper< Dali::Property > arg2 ;
39451   Dali::Property::Value arg3 ;
39452   Dali::AlphaFunction arg4 ;
39453   Dali::Property *argp2 ;
39454   Dali::Property::Value *argp3 ;
39455   Dali::AlphaFunction *argp4 ;
39456
39457   arg1 = (Dali::Animation *)jarg1;
39458   argp2 = (Dali::Property *)jarg2;
39459   if (!argp2) {
39460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39461     return ;
39462   }
39463   arg2 = *argp2;
39464   argp3 = (Dali::Property::Value *)jarg3;
39465   if (!argp3) {
39466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39467     return ;
39468   }
39469   arg3 = *argp3;
39470   argp4 = (Dali::AlphaFunction *)jarg4;
39471   if (!argp4) {
39472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39473     return ;
39474   }
39475   arg4 = *argp4;
39476   {
39477     try {
39478       (arg1)->AnimateTo(arg2,arg3,arg4);
39479     } catch (std::out_of_range& e) {
39480       {
39481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39482       };
39483     } catch (std::exception& e) {
39484       {
39485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39486       };
39487     } catch (...) {
39488       {
39489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39490       };
39491     }
39492   }
39493 }
39494
39495
39496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39497   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39498   SwigValueWrapper< Dali::Property > arg2 ;
39499   Dali::Property::Value arg3 ;
39500   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39501   Dali::Property *argp2 ;
39502   Dali::Property::Value *argp3 ;
39503   Dali::TimePeriod *argp4 ;
39504
39505   arg1 = (Dali::Animation *)jarg1;
39506   argp2 = (Dali::Property *)jarg2;
39507   if (!argp2) {
39508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39509     return ;
39510   }
39511   arg2 = *argp2;
39512   argp3 = (Dali::Property::Value *)jarg3;
39513   if (!argp3) {
39514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39515     return ;
39516   }
39517   arg3 = *argp3;
39518   argp4 = (Dali::TimePeriod *)jarg4;
39519   if (!argp4) {
39520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39521     return ;
39522   }
39523   arg4 = *argp4;
39524   {
39525     try {
39526       (arg1)->AnimateTo(arg2,arg3,arg4);
39527     } catch (std::out_of_range& e) {
39528       {
39529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39530       };
39531     } catch (std::exception& e) {
39532       {
39533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39534       };
39535     } catch (...) {
39536       {
39537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39538       };
39539     }
39540   }
39541 }
39542
39543
39544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39545   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39546   SwigValueWrapper< Dali::Property > arg2 ;
39547   Dali::Property::Value arg3 ;
39548   Dali::AlphaFunction arg4 ;
39549   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39550   Dali::Property *argp2 ;
39551   Dali::Property::Value *argp3 ;
39552   Dali::AlphaFunction *argp4 ;
39553   Dali::TimePeriod *argp5 ;
39554
39555   arg1 = (Dali::Animation *)jarg1;
39556   argp2 = (Dali::Property *)jarg2;
39557   if (!argp2) {
39558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39559     return ;
39560   }
39561   arg2 = *argp2;
39562   argp3 = (Dali::Property::Value *)jarg3;
39563   if (!argp3) {
39564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39565     return ;
39566   }
39567   arg3 = *argp3;
39568   argp4 = (Dali::AlphaFunction *)jarg4;
39569   if (!argp4) {
39570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39571     return ;
39572   }
39573   arg4 = *argp4;
39574   argp5 = (Dali::TimePeriod *)jarg5;
39575   if (!argp5) {
39576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39577     return ;
39578   }
39579   arg5 = *argp5;
39580   {
39581     try {
39582       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39583     } catch (std::out_of_range& e) {
39584       {
39585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39586       };
39587     } catch (std::exception& e) {
39588       {
39589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39590       };
39591     } catch (...) {
39592       {
39593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39594       };
39595     }
39596   }
39597 }
39598
39599
39600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39601   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39602   SwigValueWrapper< Dali::Property > arg2 ;
39603   Dali::KeyFrames *arg3 = 0 ;
39604   Dali::Property *argp2 ;
39605
39606   arg1 = (Dali::Animation *)jarg1;
39607   argp2 = (Dali::Property *)jarg2;
39608   if (!argp2) {
39609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39610     return ;
39611   }
39612   arg2 = *argp2;
39613   arg3 = (Dali::KeyFrames *)jarg3;
39614   if (!arg3) {
39615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39616     return ;
39617   }
39618   {
39619     try {
39620       (arg1)->AnimateBetween(arg2,*arg3);
39621     } catch (std::out_of_range& e) {
39622       {
39623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39624       };
39625     } catch (std::exception& e) {
39626       {
39627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39628       };
39629     } catch (...) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39632       };
39633     }
39634   }
39635 }
39636
39637
39638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39639   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39640   SwigValueWrapper< Dali::Property > arg2 ;
39641   Dali::KeyFrames *arg3 = 0 ;
39642   Dali::Animation::Interpolation arg4 ;
39643   Dali::Property *argp2 ;
39644
39645   arg1 = (Dali::Animation *)jarg1;
39646   argp2 = (Dali::Property *)jarg2;
39647   if (!argp2) {
39648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39649     return ;
39650   }
39651   arg2 = *argp2;
39652   arg3 = (Dali::KeyFrames *)jarg3;
39653   if (!arg3) {
39654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39655     return ;
39656   }
39657   arg4 = (Dali::Animation::Interpolation)jarg4;
39658   {
39659     try {
39660       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39661     } catch (std::out_of_range& e) {
39662       {
39663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39664       };
39665     } catch (std::exception& e) {
39666       {
39667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39668       };
39669     } catch (...) {
39670       {
39671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39672       };
39673     }
39674   }
39675 }
39676
39677
39678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39679   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39680   SwigValueWrapper< Dali::Property > arg2 ;
39681   Dali::KeyFrames *arg3 = 0 ;
39682   Dali::AlphaFunction arg4 ;
39683   Dali::Property *argp2 ;
39684   Dali::AlphaFunction *argp4 ;
39685
39686   arg1 = (Dali::Animation *)jarg1;
39687   argp2 = (Dali::Property *)jarg2;
39688   if (!argp2) {
39689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39690     return ;
39691   }
39692   arg2 = *argp2;
39693   arg3 = (Dali::KeyFrames *)jarg3;
39694   if (!arg3) {
39695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39696     return ;
39697   }
39698   argp4 = (Dali::AlphaFunction *)jarg4;
39699   if (!argp4) {
39700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39701     return ;
39702   }
39703   arg4 = *argp4;
39704   {
39705     try {
39706       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39707     } catch (std::out_of_range& e) {
39708       {
39709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39710       };
39711     } catch (std::exception& e) {
39712       {
39713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39714       };
39715     } catch (...) {
39716       {
39717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39718       };
39719     }
39720   }
39721 }
39722
39723
39724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39725   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39726   SwigValueWrapper< Dali::Property > arg2 ;
39727   Dali::KeyFrames *arg3 = 0 ;
39728   Dali::AlphaFunction arg4 ;
39729   Dali::Animation::Interpolation arg5 ;
39730   Dali::Property *argp2 ;
39731   Dali::AlphaFunction *argp4 ;
39732
39733   arg1 = (Dali::Animation *)jarg1;
39734   argp2 = (Dali::Property *)jarg2;
39735   if (!argp2) {
39736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39737     return ;
39738   }
39739   arg2 = *argp2;
39740   arg3 = (Dali::KeyFrames *)jarg3;
39741   if (!arg3) {
39742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39743     return ;
39744   }
39745   argp4 = (Dali::AlphaFunction *)jarg4;
39746   if (!argp4) {
39747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39748     return ;
39749   }
39750   arg4 = *argp4;
39751   arg5 = (Dali::Animation::Interpolation)jarg5;
39752   {
39753     try {
39754       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39755     } catch (std::out_of_range& e) {
39756       {
39757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39758       };
39759     } catch (std::exception& e) {
39760       {
39761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39762       };
39763     } catch (...) {
39764       {
39765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39766       };
39767     }
39768   }
39769 }
39770
39771
39772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39773   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39774   SwigValueWrapper< Dali::Property > arg2 ;
39775   Dali::KeyFrames *arg3 = 0 ;
39776   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39777   Dali::Property *argp2 ;
39778   Dali::TimePeriod *argp4 ;
39779
39780   arg1 = (Dali::Animation *)jarg1;
39781   argp2 = (Dali::Property *)jarg2;
39782   if (!argp2) {
39783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39784     return ;
39785   }
39786   arg2 = *argp2;
39787   arg3 = (Dali::KeyFrames *)jarg3;
39788   if (!arg3) {
39789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39790     return ;
39791   }
39792   argp4 = (Dali::TimePeriod *)jarg4;
39793   if (!argp4) {
39794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39795     return ;
39796   }
39797   arg4 = *argp4;
39798   {
39799     try {
39800       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39801     } catch (std::out_of_range& e) {
39802       {
39803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39804       };
39805     } catch (std::exception& e) {
39806       {
39807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39808       };
39809     } catch (...) {
39810       {
39811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39812       };
39813     }
39814   }
39815 }
39816
39817
39818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39819   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39820   SwigValueWrapper< Dali::Property > arg2 ;
39821   Dali::KeyFrames *arg3 = 0 ;
39822   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39823   Dali::Animation::Interpolation arg5 ;
39824   Dali::Property *argp2 ;
39825   Dali::TimePeriod *argp4 ;
39826
39827   arg1 = (Dali::Animation *)jarg1;
39828   argp2 = (Dali::Property *)jarg2;
39829   if (!argp2) {
39830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39831     return ;
39832   }
39833   arg2 = *argp2;
39834   arg3 = (Dali::KeyFrames *)jarg3;
39835   if (!arg3) {
39836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39837     return ;
39838   }
39839   argp4 = (Dali::TimePeriod *)jarg4;
39840   if (!argp4) {
39841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39842     return ;
39843   }
39844   arg4 = *argp4;
39845   arg5 = (Dali::Animation::Interpolation)jarg5;
39846   {
39847     try {
39848       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39849     } catch (std::out_of_range& e) {
39850       {
39851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39852       };
39853     } catch (std::exception& e) {
39854       {
39855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39856       };
39857     } catch (...) {
39858       {
39859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39860       };
39861     }
39862   }
39863 }
39864
39865
39866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39867   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39868   SwigValueWrapper< Dali::Property > arg2 ;
39869   Dali::KeyFrames *arg3 = 0 ;
39870   Dali::AlphaFunction arg4 ;
39871   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39872   Dali::Property *argp2 ;
39873   Dali::AlphaFunction *argp4 ;
39874   Dali::TimePeriod *argp5 ;
39875
39876   arg1 = (Dali::Animation *)jarg1;
39877   argp2 = (Dali::Property *)jarg2;
39878   if (!argp2) {
39879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39880     return ;
39881   }
39882   arg2 = *argp2;
39883   arg3 = (Dali::KeyFrames *)jarg3;
39884   if (!arg3) {
39885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39886     return ;
39887   }
39888   argp4 = (Dali::AlphaFunction *)jarg4;
39889   if (!argp4) {
39890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39891     return ;
39892   }
39893   arg4 = *argp4;
39894   argp5 = (Dali::TimePeriod *)jarg5;
39895   if (!argp5) {
39896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39897     return ;
39898   }
39899   arg5 = *argp5;
39900   {
39901     try {
39902       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39903     } catch (std::out_of_range& e) {
39904       {
39905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39906       };
39907     } catch (std::exception& e) {
39908       {
39909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39910       };
39911     } catch (...) {
39912       {
39913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39914       };
39915     }
39916   }
39917 }
39918
39919
39920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
39921   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39922   SwigValueWrapper< Dali::Property > arg2 ;
39923   Dali::KeyFrames *arg3 = 0 ;
39924   Dali::AlphaFunction arg4 ;
39925   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39926   Dali::Animation::Interpolation arg6 ;
39927   Dali::Property *argp2 ;
39928   Dali::AlphaFunction *argp4 ;
39929   Dali::TimePeriod *argp5 ;
39930
39931   arg1 = (Dali::Animation *)jarg1;
39932   argp2 = (Dali::Property *)jarg2;
39933   if (!argp2) {
39934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39935     return ;
39936   }
39937   arg2 = *argp2;
39938   arg3 = (Dali::KeyFrames *)jarg3;
39939   if (!arg3) {
39940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39941     return ;
39942   }
39943   argp4 = (Dali::AlphaFunction *)jarg4;
39944   if (!argp4) {
39945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39946     return ;
39947   }
39948   arg4 = *argp4;
39949   argp5 = (Dali::TimePeriod *)jarg5;
39950   if (!argp5) {
39951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39952     return ;
39953   }
39954   arg5 = *argp5;
39955   arg6 = (Dali::Animation::Interpolation)jarg6;
39956   {
39957     try {
39958       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
39959     } catch (std::out_of_range& e) {
39960       {
39961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39962       };
39963     } catch (std::exception& e) {
39964       {
39965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39966       };
39967     } catch (...) {
39968       {
39969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39970       };
39971     }
39972   }
39973 }
39974
39975
39976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39977   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39978   Dali::Actor arg2 ;
39979   Dali::Path arg3 ;
39980   Dali::Vector3 *arg4 = 0 ;
39981   Dali::Actor *argp2 ;
39982   Dali::Path *argp3 ;
39983
39984   arg1 = (Dali::Animation *)jarg1;
39985   argp2 = (Dali::Actor *)jarg2;
39986   if (!argp2) {
39987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
39988     return ;
39989   }
39990   arg2 = *argp2;
39991   argp3 = (Dali::Path *)jarg3;
39992   if (!argp3) {
39993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
39994     return ;
39995   }
39996   arg3 = *argp3;
39997   arg4 = (Dali::Vector3 *)jarg4;
39998   if (!arg4) {
39999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40000     return ;
40001   }
40002   {
40003     try {
40004       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40005     } catch (std::out_of_range& e) {
40006       {
40007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40008       };
40009     } catch (std::exception& e) {
40010       {
40011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40012       };
40013     } catch (...) {
40014       {
40015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40016       };
40017     }
40018   }
40019 }
40020
40021
40022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40023   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40024   Dali::Actor arg2 ;
40025   Dali::Path arg3 ;
40026   Dali::Vector3 *arg4 = 0 ;
40027   Dali::AlphaFunction arg5 ;
40028   Dali::Actor *argp2 ;
40029   Dali::Path *argp3 ;
40030   Dali::AlphaFunction *argp5 ;
40031
40032   arg1 = (Dali::Animation *)jarg1;
40033   argp2 = (Dali::Actor *)jarg2;
40034   if (!argp2) {
40035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40036     return ;
40037   }
40038   arg2 = *argp2;
40039   argp3 = (Dali::Path *)jarg3;
40040   if (!argp3) {
40041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40042     return ;
40043   }
40044   arg3 = *argp3;
40045   arg4 = (Dali::Vector3 *)jarg4;
40046   if (!arg4) {
40047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40048     return ;
40049   }
40050   argp5 = (Dali::AlphaFunction *)jarg5;
40051   if (!argp5) {
40052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40053     return ;
40054   }
40055   arg5 = *argp5;
40056   {
40057     try {
40058       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40059     } catch (std::out_of_range& e) {
40060       {
40061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40062       };
40063     } catch (std::exception& e) {
40064       {
40065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40066       };
40067     } catch (...) {
40068       {
40069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40070       };
40071     }
40072   }
40073 }
40074
40075
40076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40077   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40078   Dali::Actor arg2 ;
40079   Dali::Path arg3 ;
40080   Dali::Vector3 *arg4 = 0 ;
40081   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40082   Dali::Actor *argp2 ;
40083   Dali::Path *argp3 ;
40084   Dali::TimePeriod *argp5 ;
40085
40086   arg1 = (Dali::Animation *)jarg1;
40087   argp2 = (Dali::Actor *)jarg2;
40088   if (!argp2) {
40089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40090     return ;
40091   }
40092   arg2 = *argp2;
40093   argp3 = (Dali::Path *)jarg3;
40094   if (!argp3) {
40095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40096     return ;
40097   }
40098   arg3 = *argp3;
40099   arg4 = (Dali::Vector3 *)jarg4;
40100   if (!arg4) {
40101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40102     return ;
40103   }
40104   argp5 = (Dali::TimePeriod *)jarg5;
40105   if (!argp5) {
40106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40107     return ;
40108   }
40109   arg5 = *argp5;
40110   {
40111     try {
40112       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40113     } catch (std::out_of_range& e) {
40114       {
40115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40116       };
40117     } catch (std::exception& e) {
40118       {
40119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40120       };
40121     } catch (...) {
40122       {
40123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40124       };
40125     }
40126   }
40127 }
40128
40129
40130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40131   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40132   Dali::Actor arg2 ;
40133   Dali::Path arg3 ;
40134   Dali::Vector3 *arg4 = 0 ;
40135   Dali::AlphaFunction arg5 ;
40136   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40137   Dali::Actor *argp2 ;
40138   Dali::Path *argp3 ;
40139   Dali::AlphaFunction *argp5 ;
40140   Dali::TimePeriod *argp6 ;
40141
40142   arg1 = (Dali::Animation *)jarg1;
40143   argp2 = (Dali::Actor *)jarg2;
40144   if (!argp2) {
40145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40146     return ;
40147   }
40148   arg2 = *argp2;
40149   argp3 = (Dali::Path *)jarg3;
40150   if (!argp3) {
40151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40152     return ;
40153   }
40154   arg3 = *argp3;
40155   arg4 = (Dali::Vector3 *)jarg4;
40156   if (!arg4) {
40157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40158     return ;
40159   }
40160   argp5 = (Dali::AlphaFunction *)jarg5;
40161   if (!argp5) {
40162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40163     return ;
40164   }
40165   arg5 = *argp5;
40166   argp6 = (Dali::TimePeriod *)jarg6;
40167   if (!argp6) {
40168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40169     return ;
40170   }
40171   arg6 = *argp6;
40172   {
40173     try {
40174       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40175     } catch (std::out_of_range& e) {
40176       {
40177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40178       };
40179     } catch (std::exception& e) {
40180       {
40181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40182       };
40183     } catch (...) {
40184       {
40185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40186       };
40187     }
40188   }
40189 }
40190
40191
40192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40193   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40194   Dali::Actor arg2 ;
40195   float arg3 ;
40196   Dali::Actor *argp2 ;
40197
40198   arg1 = (Dali::Animation *)jarg1;
40199   argp2 = (Dali::Actor *)jarg2;
40200   if (!argp2) {
40201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40202     return ;
40203   }
40204   arg2 = *argp2;
40205   arg3 = (float)jarg3;
40206   {
40207     try {
40208       (arg1)->Show(arg2,arg3);
40209     } catch (std::out_of_range& e) {
40210       {
40211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40212       };
40213     } catch (std::exception& e) {
40214       {
40215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40216       };
40217     } catch (...) {
40218       {
40219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40220       };
40221     }
40222   }
40223 }
40224
40225
40226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40227   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40228   Dali::Actor arg2 ;
40229   float arg3 ;
40230   Dali::Actor *argp2 ;
40231
40232   arg1 = (Dali::Animation *)jarg1;
40233   argp2 = (Dali::Actor *)jarg2;
40234   if (!argp2) {
40235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40236     return ;
40237   }
40238   arg2 = *argp2;
40239   arg3 = (float)jarg3;
40240   {
40241     try {
40242       (arg1)->Hide(arg2,arg3);
40243     } catch (std::out_of_range& e) {
40244       {
40245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40246       };
40247     } catch (std::exception& e) {
40248       {
40249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40250       };
40251     } catch (...) {
40252       {
40253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40254       };
40255     }
40256   }
40257 }
40258
40259
40260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40261   int jresult ;
40262   int result;
40263
40264   result = (int)Dali::LinearConstrainer::Property::VALUE;
40265   jresult = (int)result;
40266   return jresult;
40267 }
40268
40269
40270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40271   int jresult ;
40272   int result;
40273
40274   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40275   jresult = (int)result;
40276   return jresult;
40277 }
40278
40279
40280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40281   void * jresult ;
40282   Dali::LinearConstrainer::Property *result = 0 ;
40283
40284   {
40285     try {
40286       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40287     } catch (std::out_of_range& e) {
40288       {
40289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40290       };
40291     } catch (std::exception& e) {
40292       {
40293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40294       };
40295     } catch (...) {
40296       {
40297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40298       };
40299     }
40300   }
40301   jresult = (void *)result;
40302   return jresult;
40303 }
40304
40305
40306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40307   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40308
40309   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40310   {
40311     try {
40312       delete arg1;
40313     } catch (std::out_of_range& e) {
40314       {
40315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40316       };
40317     } catch (std::exception& e) {
40318       {
40319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40320       };
40321     } catch (...) {
40322       {
40323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40324       };
40325     }
40326   }
40327 }
40328
40329
40330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40331   void * jresult ;
40332   Dali::LinearConstrainer result;
40333
40334   {
40335     try {
40336       result = Dali::LinearConstrainer::New();
40337     } catch (std::out_of_range& e) {
40338       {
40339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40340       };
40341     } catch (std::exception& e) {
40342       {
40343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40344       };
40345     } catch (...) {
40346       {
40347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40348       };
40349     }
40350   }
40351   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40352   return jresult;
40353 }
40354
40355
40356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40357   void * jresult ;
40358   Dali::BaseHandle arg1 ;
40359   Dali::BaseHandle *argp1 ;
40360   Dali::LinearConstrainer result;
40361
40362   argp1 = (Dali::BaseHandle *)jarg1;
40363   if (!argp1) {
40364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40365     return 0;
40366   }
40367   arg1 = *argp1;
40368   {
40369     try {
40370       result = Dali::LinearConstrainer::DownCast(arg1);
40371     } catch (std::out_of_range& e) {
40372       {
40373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40374       };
40375     } catch (std::exception& e) {
40376       {
40377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40378       };
40379     } catch (...) {
40380       {
40381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40382       };
40383     }
40384   }
40385   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40386   return jresult;
40387 }
40388
40389
40390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40391   void * jresult ;
40392   Dali::LinearConstrainer *result = 0 ;
40393
40394   {
40395     try {
40396       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40397     } catch (std::out_of_range& e) {
40398       {
40399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40400       };
40401     } catch (std::exception& e) {
40402       {
40403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40404       };
40405     } catch (...) {
40406       {
40407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40408       };
40409     }
40410   }
40411   jresult = (void *)result;
40412   return jresult;
40413 }
40414
40415
40416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40417   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40418
40419   arg1 = (Dali::LinearConstrainer *)jarg1;
40420   {
40421     try {
40422       delete arg1;
40423     } catch (std::out_of_range& e) {
40424       {
40425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40426       };
40427     } catch (std::exception& e) {
40428       {
40429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40430       };
40431     } catch (...) {
40432       {
40433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40434       };
40435     }
40436   }
40437 }
40438
40439
40440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40441   void * jresult ;
40442   Dali::LinearConstrainer *arg1 = 0 ;
40443   Dali::LinearConstrainer *result = 0 ;
40444
40445   arg1 = (Dali::LinearConstrainer *)jarg1;
40446   if (!arg1) {
40447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40448     return 0;
40449   }
40450   {
40451     try {
40452       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40453     } catch (std::out_of_range& e) {
40454       {
40455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40456       };
40457     } catch (std::exception& e) {
40458       {
40459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40460       };
40461     } catch (...) {
40462       {
40463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40464       };
40465     }
40466   }
40467   jresult = (void *)result;
40468   return jresult;
40469 }
40470
40471
40472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40473   void * jresult ;
40474   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40475   Dali::LinearConstrainer *arg2 = 0 ;
40476   Dali::LinearConstrainer *result = 0 ;
40477
40478   arg1 = (Dali::LinearConstrainer *)jarg1;
40479   arg2 = (Dali::LinearConstrainer *)jarg2;
40480   if (!arg2) {
40481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40482     return 0;
40483   }
40484   {
40485     try {
40486       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40487     } catch (std::out_of_range& e) {
40488       {
40489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40490       };
40491     } catch (std::exception& e) {
40492       {
40493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40494       };
40495     } catch (...) {
40496       {
40497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40498       };
40499     }
40500   }
40501   jresult = (void *)result;
40502   return jresult;
40503 }
40504
40505
40506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40507   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40508   SwigValueWrapper< Dali::Property > arg2 ;
40509   SwigValueWrapper< Dali::Property > arg3 ;
40510   Dali::Vector2 *arg4 = 0 ;
40511   Dali::Vector2 *arg5 = 0 ;
40512   Dali::Property *argp2 ;
40513   Dali::Property *argp3 ;
40514
40515   arg1 = (Dali::LinearConstrainer *)jarg1;
40516   argp2 = (Dali::Property *)jarg2;
40517   if (!argp2) {
40518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40519     return ;
40520   }
40521   arg2 = *argp2;
40522   argp3 = (Dali::Property *)jarg3;
40523   if (!argp3) {
40524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40525     return ;
40526   }
40527   arg3 = *argp3;
40528   arg4 = (Dali::Vector2 *)jarg4;
40529   if (!arg4) {
40530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40531     return ;
40532   }
40533   arg5 = (Dali::Vector2 *)jarg5;
40534   if (!arg5) {
40535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40536     return ;
40537   }
40538   {
40539     try {
40540       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40541     } catch (std::out_of_range& e) {
40542       {
40543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40544       };
40545     } catch (std::exception& e) {
40546       {
40547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40548       };
40549     } catch (...) {
40550       {
40551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40552       };
40553     }
40554   }
40555 }
40556
40557
40558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40559   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40560   SwigValueWrapper< Dali::Property > arg2 ;
40561   SwigValueWrapper< Dali::Property > arg3 ;
40562   Dali::Vector2 *arg4 = 0 ;
40563   Dali::Property *argp2 ;
40564   Dali::Property *argp3 ;
40565
40566   arg1 = (Dali::LinearConstrainer *)jarg1;
40567   argp2 = (Dali::Property *)jarg2;
40568   if (!argp2) {
40569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40570     return ;
40571   }
40572   arg2 = *argp2;
40573   argp3 = (Dali::Property *)jarg3;
40574   if (!argp3) {
40575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40576     return ;
40577   }
40578   arg3 = *argp3;
40579   arg4 = (Dali::Vector2 *)jarg4;
40580   if (!arg4) {
40581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40582     return ;
40583   }
40584   {
40585     try {
40586       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40587     } catch (std::out_of_range& e) {
40588       {
40589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40590       };
40591     } catch (std::exception& e) {
40592       {
40593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40594       };
40595     } catch (...) {
40596       {
40597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40598       };
40599     }
40600   }
40601 }
40602
40603
40604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40605   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40606   Dali::Handle *arg2 = 0 ;
40607
40608   arg1 = (Dali::LinearConstrainer *)jarg1;
40609   arg2 = (Dali::Handle *)jarg2;
40610   if (!arg2) {
40611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40612     return ;
40613   }
40614   {
40615     try {
40616       (arg1)->Remove(*arg2);
40617     } catch (std::out_of_range& e) {
40618       {
40619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40620       };
40621     } catch (std::exception& e) {
40622       {
40623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40624       };
40625     } catch (...) {
40626       {
40627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40628       };
40629     }
40630   }
40631 }
40632
40633
40634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40635   int jresult ;
40636   int result;
40637
40638   result = (int)Dali::PathConstrainer::Property::FORWARD;
40639   jresult = (int)result;
40640   return jresult;
40641 }
40642
40643
40644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40645   int jresult ;
40646   int result;
40647
40648   result = (int)Dali::PathConstrainer::Property::POINTS;
40649   jresult = (int)result;
40650   return jresult;
40651 }
40652
40653
40654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40655   int jresult ;
40656   int result;
40657
40658   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40659   jresult = (int)result;
40660   return jresult;
40661 }
40662
40663
40664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40665   void * jresult ;
40666   Dali::PathConstrainer::Property *result = 0 ;
40667
40668   {
40669     try {
40670       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40671     } catch (std::out_of_range& e) {
40672       {
40673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40674       };
40675     } catch (std::exception& e) {
40676       {
40677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40678       };
40679     } catch (...) {
40680       {
40681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40682       };
40683     }
40684   }
40685   jresult = (void *)result;
40686   return jresult;
40687 }
40688
40689
40690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40691   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40692
40693   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40694   {
40695     try {
40696       delete arg1;
40697     } catch (std::out_of_range& e) {
40698       {
40699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40700       };
40701     } catch (std::exception& e) {
40702       {
40703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40704       };
40705     } catch (...) {
40706       {
40707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40708       };
40709     }
40710   }
40711 }
40712
40713
40714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40715   void * jresult ;
40716   Dali::PathConstrainer result;
40717
40718   {
40719     try {
40720       result = Dali::PathConstrainer::New();
40721     } catch (std::out_of_range& e) {
40722       {
40723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40724       };
40725     } catch (std::exception& e) {
40726       {
40727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40728       };
40729     } catch (...) {
40730       {
40731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40732       };
40733     }
40734   }
40735   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40736   return jresult;
40737 }
40738
40739
40740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40741   void * jresult ;
40742   Dali::BaseHandle arg1 ;
40743   Dali::BaseHandle *argp1 ;
40744   Dali::PathConstrainer result;
40745
40746   argp1 = (Dali::BaseHandle *)jarg1;
40747   if (!argp1) {
40748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40749     return 0;
40750   }
40751   arg1 = *argp1;
40752   {
40753     try {
40754       result = Dali::PathConstrainer::DownCast(arg1);
40755     } catch (std::out_of_range& e) {
40756       {
40757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40758       };
40759     } catch (std::exception& e) {
40760       {
40761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40762       };
40763     } catch (...) {
40764       {
40765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40766       };
40767     }
40768   }
40769   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40770   return jresult;
40771 }
40772
40773
40774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40775   void * jresult ;
40776   Dali::PathConstrainer *result = 0 ;
40777
40778   {
40779     try {
40780       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40781     } catch (std::out_of_range& e) {
40782       {
40783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40784       };
40785     } catch (std::exception& e) {
40786       {
40787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40788       };
40789     } catch (...) {
40790       {
40791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40792       };
40793     }
40794   }
40795   jresult = (void *)result;
40796   return jresult;
40797 }
40798
40799
40800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40801   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40802
40803   arg1 = (Dali::PathConstrainer *)jarg1;
40804   {
40805     try {
40806       delete arg1;
40807     } catch (std::out_of_range& e) {
40808       {
40809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40810       };
40811     } catch (std::exception& e) {
40812       {
40813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40814       };
40815     } catch (...) {
40816       {
40817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40818       };
40819     }
40820   }
40821 }
40822
40823
40824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
40825   void * jresult ;
40826   Dali::PathConstrainer *arg1 = 0 ;
40827   Dali::PathConstrainer *result = 0 ;
40828
40829   arg1 = (Dali::PathConstrainer *)jarg1;
40830   if (!arg1) {
40831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40832     return 0;
40833   }
40834   {
40835     try {
40836       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
40837     } catch (std::out_of_range& e) {
40838       {
40839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40840       };
40841     } catch (std::exception& e) {
40842       {
40843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40844       };
40845     } catch (...) {
40846       {
40847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40848       };
40849     }
40850   }
40851   jresult = (void *)result;
40852   return jresult;
40853 }
40854
40855
40856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
40857   void * jresult ;
40858   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40859   Dali::PathConstrainer *arg2 = 0 ;
40860   Dali::PathConstrainer *result = 0 ;
40861
40862   arg1 = (Dali::PathConstrainer *)jarg1;
40863   arg2 = (Dali::PathConstrainer *)jarg2;
40864   if (!arg2) {
40865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
40866     return 0;
40867   }
40868   {
40869     try {
40870       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
40871     } catch (std::out_of_range& e) {
40872       {
40873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40874       };
40875     } catch (std::exception& e) {
40876       {
40877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40878       };
40879     } catch (...) {
40880       {
40881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40882       };
40883     }
40884   }
40885   jresult = (void *)result;
40886   return jresult;
40887 }
40888
40889
40890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40891   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40892   SwigValueWrapper< Dali::Property > arg2 ;
40893   SwigValueWrapper< Dali::Property > arg3 ;
40894   Dali::Vector2 *arg4 = 0 ;
40895   Dali::Vector2 *arg5 = 0 ;
40896   Dali::Property *argp2 ;
40897   Dali::Property *argp3 ;
40898
40899   arg1 = (Dali::PathConstrainer *)jarg1;
40900   argp2 = (Dali::Property *)jarg2;
40901   if (!argp2) {
40902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40903     return ;
40904   }
40905   arg2 = *argp2;
40906   argp3 = (Dali::Property *)jarg3;
40907   if (!argp3) {
40908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40909     return ;
40910   }
40911   arg3 = *argp3;
40912   arg4 = (Dali::Vector2 *)jarg4;
40913   if (!arg4) {
40914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40915     return ;
40916   }
40917   arg5 = (Dali::Vector2 *)jarg5;
40918   if (!arg5) {
40919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40920     return ;
40921   }
40922   {
40923     try {
40924       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40925     } catch (std::out_of_range& e) {
40926       {
40927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40928       };
40929     } catch (std::exception& e) {
40930       {
40931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40932       };
40933     } catch (...) {
40934       {
40935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40936       };
40937     }
40938   }
40939 }
40940
40941
40942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40943   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40944   SwigValueWrapper< Dali::Property > arg2 ;
40945   SwigValueWrapper< Dali::Property > arg3 ;
40946   Dali::Vector2 *arg4 = 0 ;
40947   Dali::Property *argp2 ;
40948   Dali::Property *argp3 ;
40949
40950   arg1 = (Dali::PathConstrainer *)jarg1;
40951   argp2 = (Dali::Property *)jarg2;
40952   if (!argp2) {
40953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40954     return ;
40955   }
40956   arg2 = *argp2;
40957   argp3 = (Dali::Property *)jarg3;
40958   if (!argp3) {
40959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40960     return ;
40961   }
40962   arg3 = *argp3;
40963   arg4 = (Dali::Vector2 *)jarg4;
40964   if (!arg4) {
40965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40966     return ;
40967   }
40968   {
40969     try {
40970       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40971     } catch (std::out_of_range& e) {
40972       {
40973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40974       };
40975     } catch (std::exception& e) {
40976       {
40977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40978       };
40979     } catch (...) {
40980       {
40981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40982       };
40983     }
40984   }
40985 }
40986
40987
40988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
40989   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40990   Dali::Handle *arg2 = 0 ;
40991
40992   arg1 = (Dali::PathConstrainer *)jarg1;
40993   arg2 = (Dali::Handle *)jarg2;
40994   if (!arg2) {
40995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40996     return ;
40997   }
40998   {
40999     try {
41000       (arg1)->Remove(*arg2);
41001     } catch (std::out_of_range& e) {
41002       {
41003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41004       };
41005     } catch (std::exception& e) {
41006       {
41007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41008       };
41009     } catch (...) {
41010       {
41011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41012       };
41013     }
41014   }
41015 }
41016
41017
41018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41019   int jresult ;
41020   Dali::FittingMode::Type result;
41021
41022   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41023   jresult = (int)result;
41024   return jresult;
41025 }
41026
41027
41028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41029   int jresult ;
41030   Dali::SamplingMode::Type result;
41031
41032   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41033   jresult = (int)result;
41034   return jresult;
41035 }
41036
41037
41038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41039   void * jresult ;
41040   Dali::BufferImage *result = 0 ;
41041
41042   {
41043     try {
41044       result = (Dali::BufferImage *)new Dali::BufferImage();
41045     } catch (std::out_of_range& e) {
41046       {
41047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41048       };
41049     } catch (std::exception& e) {
41050       {
41051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41052       };
41053     } catch (...) {
41054       {
41055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41056       };
41057     }
41058   }
41059   jresult = (void *)result;
41060   return jresult;
41061 }
41062
41063
41064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41065   void * jresult ;
41066   unsigned int arg1 ;
41067   unsigned int arg2 ;
41068   Dali::Pixel::Format arg3 ;
41069   Dali::BufferImage result;
41070
41071   arg1 = (unsigned int)jarg1;
41072   arg2 = (unsigned int)jarg2;
41073   arg3 = (Dali::Pixel::Format)jarg3;
41074   {
41075     try {
41076       result = Dali::BufferImage::New(arg1,arg2,arg3);
41077     } catch (std::out_of_range& e) {
41078       {
41079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41080       };
41081     } catch (std::exception& e) {
41082       {
41083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41084       };
41085     } catch (...) {
41086       {
41087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41088       };
41089     }
41090   }
41091   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41092   return jresult;
41093 }
41094
41095
41096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41097   void * jresult ;
41098   unsigned int arg1 ;
41099   unsigned int arg2 ;
41100   Dali::BufferImage result;
41101
41102   arg1 = (unsigned int)jarg1;
41103   arg2 = (unsigned int)jarg2;
41104   {
41105     try {
41106       result = Dali::BufferImage::New(arg1,arg2);
41107     } catch (std::out_of_range& e) {
41108       {
41109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41110       };
41111     } catch (std::exception& e) {
41112       {
41113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41114       };
41115     } catch (...) {
41116       {
41117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41118       };
41119     }
41120   }
41121   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41122   return jresult;
41123 }
41124
41125
41126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41127   void * jresult ;
41128   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41129   unsigned int arg2 ;
41130   unsigned int arg3 ;
41131   Dali::Pixel::Format arg4 ;
41132   unsigned int arg5 ;
41133   Dali::BufferImage result;
41134
41135   arg1 = jarg1;
41136   arg2 = (unsigned int)jarg2;
41137   arg3 = (unsigned int)jarg3;
41138   arg4 = (Dali::Pixel::Format)jarg4;
41139   arg5 = (unsigned int)jarg5;
41140   {
41141     try {
41142       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41143     } catch (std::out_of_range& e) {
41144       {
41145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41146       };
41147     } catch (std::exception& e) {
41148       {
41149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41150       };
41151     } catch (...) {
41152       {
41153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41154       };
41155     }
41156   }
41157   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41158
41159
41160   return jresult;
41161 }
41162
41163
41164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41165   void * jresult ;
41166   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41167   unsigned int arg2 ;
41168   unsigned int arg3 ;
41169   Dali::Pixel::Format arg4 ;
41170   Dali::BufferImage result;
41171
41172   arg1 = jarg1;
41173   arg2 = (unsigned int)jarg2;
41174   arg3 = (unsigned int)jarg3;
41175   arg4 = (Dali::Pixel::Format)jarg4;
41176   {
41177     try {
41178       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41179     } catch (std::out_of_range& e) {
41180       {
41181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41182       };
41183     } catch (std::exception& e) {
41184       {
41185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41186       };
41187     } catch (...) {
41188       {
41189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41190       };
41191     }
41192   }
41193   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41194
41195
41196   return jresult;
41197 }
41198
41199
41200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41201   void * jresult ;
41202   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41203   unsigned int arg2 ;
41204   unsigned int arg3 ;
41205   Dali::BufferImage result;
41206
41207   arg1 = jarg1;
41208   arg2 = (unsigned int)jarg2;
41209   arg3 = (unsigned int)jarg3;
41210   {
41211     try {
41212       result = Dali::BufferImage::New(arg1,arg2,arg3);
41213     } catch (std::out_of_range& e) {
41214       {
41215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41216       };
41217     } catch (std::exception& e) {
41218       {
41219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41220       };
41221     } catch (...) {
41222       {
41223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41224       };
41225     }
41226   }
41227   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41228
41229
41230   return jresult;
41231 }
41232
41233
41234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41235   void * jresult ;
41236   Dali::BaseHandle arg1 ;
41237   Dali::BaseHandle *argp1 ;
41238   Dali::BufferImage result;
41239
41240   argp1 = (Dali::BaseHandle *)jarg1;
41241   if (!argp1) {
41242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41243     return 0;
41244   }
41245   arg1 = *argp1;
41246   {
41247     try {
41248       result = Dali::BufferImage::DownCast(arg1);
41249     } catch (std::out_of_range& e) {
41250       {
41251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41252       };
41253     } catch (std::exception& e) {
41254       {
41255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41256       };
41257     } catch (...) {
41258       {
41259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41260       };
41261     }
41262   }
41263   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41264   return jresult;
41265 }
41266
41267
41268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41269   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41270
41271   arg1 = (Dali::BufferImage *)jarg1;
41272   {
41273     try {
41274       delete arg1;
41275     } catch (std::out_of_range& e) {
41276       {
41277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41278       };
41279     } catch (std::exception& e) {
41280       {
41281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41282       };
41283     } catch (...) {
41284       {
41285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41286       };
41287     }
41288   }
41289 }
41290
41291
41292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41293   void * jresult ;
41294   Dali::BufferImage *arg1 = 0 ;
41295   Dali::BufferImage *result = 0 ;
41296
41297   arg1 = (Dali::BufferImage *)jarg1;
41298   if (!arg1) {
41299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41300     return 0;
41301   }
41302   {
41303     try {
41304       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41305     } catch (std::out_of_range& e) {
41306       {
41307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41308       };
41309     } catch (std::exception& e) {
41310       {
41311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41312       };
41313     } catch (...) {
41314       {
41315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41316       };
41317     }
41318   }
41319   jresult = (void *)result;
41320   return jresult;
41321 }
41322
41323
41324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41325   void * jresult ;
41326   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41327   Dali::BufferImage *arg2 = 0 ;
41328   Dali::BufferImage *result = 0 ;
41329
41330   arg1 = (Dali::BufferImage *)jarg1;
41331   arg2 = (Dali::BufferImage *)jarg2;
41332   if (!arg2) {
41333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41334     return 0;
41335   }
41336   {
41337     try {
41338       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41339     } catch (std::out_of_range& e) {
41340       {
41341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41342       };
41343     } catch (std::exception& e) {
41344       {
41345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41346       };
41347     } catch (...) {
41348       {
41349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41350       };
41351     }
41352   }
41353   jresult = (void *)result;
41354   return jresult;
41355 }
41356
41357
41358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41359   void * jresult ;
41360   Dali::BufferImage result;
41361
41362   {
41363     try {
41364       result = Dali::BufferImage::WHITE();
41365     } catch (std::out_of_range& e) {
41366       {
41367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41368       };
41369     } catch (std::exception& e) {
41370       {
41371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41372       };
41373     } catch (...) {
41374       {
41375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41376       };
41377     }
41378   }
41379   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41380   return jresult;
41381 }
41382
41383
41384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41385   void * jresult ;
41386   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41387   Dali::PixelBuffer *result = 0 ;
41388
41389   arg1 = (Dali::BufferImage *)jarg1;
41390   {
41391     try {
41392       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41393     } catch (std::out_of_range& e) {
41394       {
41395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41396       };
41397     } catch (std::exception& e) {
41398       {
41399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41400       };
41401     } catch (...) {
41402       {
41403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41404       };
41405     }
41406   }
41407   jresult = (void *)result;
41408   return jresult;
41409 }
41410
41411
41412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41413   unsigned int jresult ;
41414   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41415   unsigned int result;
41416
41417   arg1 = (Dali::BufferImage *)jarg1;
41418   {
41419     try {
41420       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41421     } catch (std::out_of_range& e) {
41422       {
41423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41424       };
41425     } catch (std::exception& e) {
41426       {
41427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41428       };
41429     } catch (...) {
41430       {
41431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41432       };
41433     }
41434   }
41435   jresult = result;
41436   return jresult;
41437 }
41438
41439
41440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41441   unsigned int jresult ;
41442   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41443   unsigned int result;
41444
41445   arg1 = (Dali::BufferImage *)jarg1;
41446   {
41447     try {
41448       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41449     } catch (std::out_of_range& e) {
41450       {
41451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41452       };
41453     } catch (std::exception& e) {
41454       {
41455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41456       };
41457     } catch (...) {
41458       {
41459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41460       };
41461     }
41462   }
41463   jresult = result;
41464   return jresult;
41465 }
41466
41467
41468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41469   int jresult ;
41470   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41471   Dali::Pixel::Format result;
41472
41473   arg1 = (Dali::BufferImage *)jarg1;
41474   {
41475     try {
41476       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41477     } catch (std::out_of_range& e) {
41478       {
41479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41480       };
41481     } catch (std::exception& e) {
41482       {
41483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41484       };
41485     } catch (...) {
41486       {
41487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41488       };
41489     }
41490   }
41491   jresult = (int)result;
41492   return jresult;
41493 }
41494
41495
41496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41497   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41498
41499   arg1 = (Dali::BufferImage *)jarg1;
41500   {
41501     try {
41502       (arg1)->Update();
41503     } catch (std::out_of_range& e) {
41504       {
41505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41506       };
41507     } catch (std::exception& e) {
41508       {
41509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41510       };
41511     } catch (...) {
41512       {
41513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41514       };
41515     }
41516   }
41517 }
41518
41519
41520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41521   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41522   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41523   Dali::RectArea *argp2 ;
41524
41525   arg1 = (Dali::BufferImage *)jarg1;
41526   argp2 = (Dali::RectArea *)jarg2;
41527   if (!argp2) {
41528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41529     return ;
41530   }
41531   arg2 = *argp2;
41532   {
41533     try {
41534       (arg1)->Update(arg2);
41535     } catch (std::out_of_range& e) {
41536       {
41537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41538       };
41539     } catch (std::exception& e) {
41540       {
41541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41542       };
41543     } catch (...) {
41544       {
41545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41546       };
41547     }
41548   }
41549 }
41550
41551
41552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41553   unsigned int jresult ;
41554   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41555   bool result;
41556
41557   arg1 = (Dali::BufferImage *)jarg1;
41558   {
41559     try {
41560       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
41561     } catch (std::out_of_range& e) {
41562       {
41563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41564       };
41565     } catch (std::exception& e) {
41566       {
41567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41568       };
41569     } catch (...) {
41570       {
41571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41572       };
41573     }
41574   }
41575   jresult = result;
41576   return jresult;
41577 }
41578
41579
41580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41581   void * jresult ;
41582   Dali::EncodedBufferImage *result = 0 ;
41583
41584   {
41585     try {
41586       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41587     } catch (std::out_of_range& e) {
41588       {
41589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41590       };
41591     } catch (std::exception& e) {
41592       {
41593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41594       };
41595     } catch (...) {
41596       {
41597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41598       };
41599     }
41600   }
41601   jresult = (void *)result;
41602   return jresult;
41603 }
41604
41605
41606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41607   void * jresult ;
41608   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41609   std::size_t arg2 ;
41610   Dali::EncodedBufferImage result;
41611
41612   arg1 = (uint8_t *)jarg1;
41613   arg2 = (std::size_t)jarg2;
41614   {
41615     try {
41616       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
41617     } catch (std::out_of_range& e) {
41618       {
41619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41620       };
41621     } catch (std::exception& e) {
41622       {
41623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41624       };
41625     } catch (...) {
41626       {
41627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41628       };
41629     }
41630   }
41631   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41632   return jresult;
41633 }
41634
41635
41636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41637   void * jresult ;
41638   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41639   std::size_t arg2 ;
41640   Dali::ImageDimensions arg3 ;
41641   Dali::FittingMode::Type arg4 ;
41642   Dali::SamplingMode::Type arg5 ;
41643   bool arg6 ;
41644   Dali::ImageDimensions *argp3 ;
41645   Dali::EncodedBufferImage result;
41646
41647   arg1 = (uint8_t *)jarg1;
41648   arg2 = (std::size_t)jarg2;
41649   argp3 = (Dali::ImageDimensions *)jarg3;
41650   if (!argp3) {
41651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41652     return 0;
41653   }
41654   arg3 = *argp3;
41655   arg4 = (Dali::FittingMode::Type)jarg4;
41656   arg5 = (Dali::SamplingMode::Type)jarg5;
41657   arg6 = jarg6 ? true : false;
41658   {
41659     try {
41660       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41661     } catch (std::out_of_range& e) {
41662       {
41663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41664       };
41665     } catch (std::exception& e) {
41666       {
41667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41668       };
41669     } catch (...) {
41670       {
41671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41672       };
41673     }
41674   }
41675   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41676   return jresult;
41677 }
41678
41679
41680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41681   void * jresult ;
41682   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41683   std::size_t arg2 ;
41684   Dali::ImageDimensions arg3 ;
41685   Dali::FittingMode::Type arg4 ;
41686   Dali::SamplingMode::Type arg5 ;
41687   Dali::ImageDimensions *argp3 ;
41688   Dali::EncodedBufferImage result;
41689
41690   arg1 = (uint8_t *)jarg1;
41691   arg2 = (std::size_t)jarg2;
41692   argp3 = (Dali::ImageDimensions *)jarg3;
41693   if (!argp3) {
41694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41695     return 0;
41696   }
41697   arg3 = *argp3;
41698   arg4 = (Dali::FittingMode::Type)jarg4;
41699   arg5 = (Dali::SamplingMode::Type)jarg5;
41700   {
41701     try {
41702       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41703     } catch (std::out_of_range& e) {
41704       {
41705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41706       };
41707     } catch (std::exception& e) {
41708       {
41709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41710       };
41711     } catch (...) {
41712       {
41713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41714       };
41715     }
41716   }
41717   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41718   return jresult;
41719 }
41720
41721
41722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41723   void * jresult ;
41724   Dali::BaseHandle arg1 ;
41725   Dali::BaseHandle *argp1 ;
41726   Dali::EncodedBufferImage result;
41727
41728   argp1 = (Dali::BaseHandle *)jarg1;
41729   if (!argp1) {
41730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41731     return 0;
41732   }
41733   arg1 = *argp1;
41734   {
41735     try {
41736       result = Dali::EncodedBufferImage::DownCast(arg1);
41737     } catch (std::out_of_range& e) {
41738       {
41739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41740       };
41741     } catch (std::exception& e) {
41742       {
41743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41744       };
41745     } catch (...) {
41746       {
41747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41748       };
41749     }
41750   }
41751   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41752   return jresult;
41753 }
41754
41755
41756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41757   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41758
41759   arg1 = (Dali::EncodedBufferImage *)jarg1;
41760   {
41761     try {
41762       delete arg1;
41763     } catch (std::out_of_range& e) {
41764       {
41765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41766       };
41767     } catch (std::exception& e) {
41768       {
41769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41770       };
41771     } catch (...) {
41772       {
41773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41774       };
41775     }
41776   }
41777 }
41778
41779
41780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41781   void * jresult ;
41782   Dali::EncodedBufferImage *arg1 = 0 ;
41783   Dali::EncodedBufferImage *result = 0 ;
41784
41785   arg1 = (Dali::EncodedBufferImage *)jarg1;
41786   if (!arg1) {
41787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41788     return 0;
41789   }
41790   {
41791     try {
41792       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41793     } catch (std::out_of_range& e) {
41794       {
41795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41796       };
41797     } catch (std::exception& e) {
41798       {
41799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41800       };
41801     } catch (...) {
41802       {
41803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41804       };
41805     }
41806   }
41807   jresult = (void *)result;
41808   return jresult;
41809 }
41810
41811
41812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
41813   void * jresult ;
41814   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41815   Dali::EncodedBufferImage *arg2 = 0 ;
41816   Dali::EncodedBufferImage *result = 0 ;
41817
41818   arg1 = (Dali::EncodedBufferImage *)jarg1;
41819   arg2 = (Dali::EncodedBufferImage *)jarg2;
41820   if (!arg2) {
41821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41822     return 0;
41823   }
41824   {
41825     try {
41826       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
41827     } catch (std::out_of_range& e) {
41828       {
41829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41830       };
41831     } catch (std::exception& e) {
41832       {
41833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41834       };
41835     } catch (...) {
41836       {
41837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41838       };
41839     }
41840   }
41841   jresult = (void *)result;
41842   return jresult;
41843 }
41844
41845
41846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
41847   void * jresult ;
41848   Dali::NativeImage *result = 0 ;
41849
41850   {
41851     try {
41852       result = (Dali::NativeImage *)new Dali::NativeImage();
41853     } catch (std::out_of_range& e) {
41854       {
41855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41856       };
41857     } catch (std::exception& e) {
41858       {
41859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41860       };
41861     } catch (...) {
41862       {
41863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41864       };
41865     }
41866   }
41867   jresult = (void *)result;
41868   return jresult;
41869 }
41870
41871
41872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
41873   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41874
41875   arg1 = (Dali::NativeImage *)jarg1;
41876   {
41877     try {
41878       delete arg1;
41879     } catch (std::out_of_range& e) {
41880       {
41881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41882       };
41883     } catch (std::exception& e) {
41884       {
41885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41886       };
41887     } catch (...) {
41888       {
41889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41890       };
41891     }
41892   }
41893 }
41894
41895
41896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
41897   void * jresult ;
41898   Dali::NativeImage *arg1 = 0 ;
41899   Dali::NativeImage *result = 0 ;
41900
41901   arg1 = (Dali::NativeImage *)jarg1;
41902   if (!arg1) {
41903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41904     return 0;
41905   }
41906   {
41907     try {
41908       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
41909     } catch (std::out_of_range& e) {
41910       {
41911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41912       };
41913     } catch (std::exception& e) {
41914       {
41915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41916       };
41917     } catch (...) {
41918       {
41919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41920       };
41921     }
41922   }
41923   jresult = (void *)result;
41924   return jresult;
41925 }
41926
41927
41928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
41929   void * jresult ;
41930   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41931   Dali::NativeImage *arg2 = 0 ;
41932   Dali::NativeImage *result = 0 ;
41933
41934   arg1 = (Dali::NativeImage *)jarg1;
41935   arg2 = (Dali::NativeImage *)jarg2;
41936   if (!arg2) {
41937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
41938     return 0;
41939   }
41940   {
41941     try {
41942       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
41943     } catch (std::out_of_range& e) {
41944       {
41945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41946       };
41947     } catch (std::exception& e) {
41948       {
41949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41950       };
41951     } catch (...) {
41952       {
41953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41954       };
41955     }
41956   }
41957   jresult = (void *)result;
41958   return jresult;
41959 }
41960
41961
41962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
41963   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
41964
41965   arg1 = (Dali::NativeImage *)jarg1;
41966   {
41967     try {
41968       (arg1)->CreateGlTexture();
41969     } catch (std::out_of_range& e) {
41970       {
41971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41972       };
41973     } catch (std::exception& e) {
41974       {
41975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41976       };
41977     } catch (...) {
41978       {
41979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41980       };
41981     }
41982   }
41983 }
41984
41985
41986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
41987   void * jresult ;
41988   NativeImageInterface *arg1 = 0 ;
41989   Dali::NativeImage result;
41990
41991   arg1 = (NativeImageInterface *)jarg1;
41992   if (!arg1) {
41993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
41994     return 0;
41995   }
41996   {
41997     try {
41998       result = Dali::NativeImage::New(*arg1);
41999     } catch (std::out_of_range& e) {
42000       {
42001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42002       };
42003     } catch (std::exception& e) {
42004       {
42005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42006       };
42007     } catch (...) {
42008       {
42009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42010       };
42011     }
42012   }
42013   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42014   return jresult;
42015 }
42016
42017
42018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42019   void * jresult ;
42020   Dali::BaseHandle arg1 ;
42021   Dali::BaseHandle *argp1 ;
42022   Dali::NativeImage result;
42023
42024   argp1 = (Dali::BaseHandle *)jarg1;
42025   if (!argp1) {
42026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42027     return 0;
42028   }
42029   arg1 = *argp1;
42030   {
42031     try {
42032       result = Dali::NativeImage::DownCast(arg1);
42033     } catch (std::out_of_range& e) {
42034       {
42035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42036       };
42037     } catch (std::exception& e) {
42038       {
42039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42040       };
42041     } catch (...) {
42042       {
42043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42044       };
42045     }
42046   }
42047   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42048   return jresult;
42049 }
42050
42051
42052 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42053   char * jresult ;
42054   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42055   char *result = 0 ;
42056
42057   arg1 = (Dali::NativeImage *)jarg1;
42058   {
42059     try {
42060       result = (char *)(arg1)->GetCustomFragmentPreFix();
42061     } catch (std::out_of_range& e) {
42062       {
42063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42064       };
42065     } catch (std::exception& e) {
42066       {
42067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42068       };
42069     } catch (...) {
42070       {
42071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42072       };
42073     }
42074   }
42075   jresult = SWIG_csharp_string_callback((const char *)result);
42076   return jresult;
42077 }
42078
42079
42080 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42081   char * jresult ;
42082   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42083   char *result = 0 ;
42084
42085   arg1 = (Dali::NativeImage *)jarg1;
42086   {
42087     try {
42088       result = (char *)(arg1)->GetCustomSamplerTypename();
42089     } catch (std::out_of_range& e) {
42090       {
42091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42092       };
42093     } catch (std::exception& e) {
42094       {
42095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42096       };
42097     } catch (...) {
42098       {
42099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42100       };
42101     }
42102   }
42103   jresult = SWIG_csharp_string_callback((const char *)result);
42104   return jresult;
42105 }
42106
42107
42108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42109   unsigned int jresult ;
42110   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42111   bool result;
42112
42113   arg1 = (Dali::NativeImageInterface *)jarg1;
42114   {
42115     try {
42116       result = (bool)(arg1)->GlExtensionCreate();
42117     } catch (std::out_of_range& e) {
42118       {
42119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42120       };
42121     } catch (std::exception& e) {
42122       {
42123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42124       };
42125     } catch (...) {
42126       {
42127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42128       };
42129     }
42130   }
42131   jresult = result;
42132   return jresult;
42133 }
42134
42135
42136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42137   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42138
42139   arg1 = (Dali::NativeImageInterface *)jarg1;
42140   {
42141     try {
42142       (arg1)->GlExtensionDestroy();
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 (...) {
42152       {
42153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42154       };
42155     }
42156   }
42157 }
42158
42159
42160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42161   unsigned int jresult ;
42162   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42163   unsigned int result;
42164
42165   arg1 = (Dali::NativeImageInterface *)jarg1;
42166   {
42167     try {
42168       result = (unsigned int)(arg1)->TargetTexture();
42169     } catch (std::out_of_range& e) {
42170       {
42171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42172       };
42173     } catch (std::exception& e) {
42174       {
42175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42176       };
42177     } catch (...) {
42178       {
42179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42180       };
42181     }
42182   }
42183   jresult = result;
42184   return jresult;
42185 }
42186
42187
42188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42189   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42190
42191   arg1 = (Dali::NativeImageInterface *)jarg1;
42192   {
42193     try {
42194       (arg1)->PrepareTexture();
42195     } catch (std::out_of_range& e) {
42196       {
42197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42198       };
42199     } catch (std::exception& e) {
42200       {
42201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42202       };
42203     } catch (...) {
42204       {
42205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42206       };
42207     }
42208   }
42209 }
42210
42211
42212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42213   unsigned int jresult ;
42214   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42215   unsigned int result;
42216
42217   arg1 = (Dali::NativeImageInterface *)jarg1;
42218   {
42219     try {
42220       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42221     } catch (std::out_of_range& e) {
42222       {
42223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42224       };
42225     } catch (std::exception& e) {
42226       {
42227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42228       };
42229     } catch (...) {
42230       {
42231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42232       };
42233     }
42234   }
42235   jresult = result;
42236   return jresult;
42237 }
42238
42239
42240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42241   unsigned int jresult ;
42242   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42243   unsigned int result;
42244
42245   arg1 = (Dali::NativeImageInterface *)jarg1;
42246   {
42247     try {
42248       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42249     } catch (std::out_of_range& e) {
42250       {
42251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42252       };
42253     } catch (std::exception& e) {
42254       {
42255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42256       };
42257     } catch (...) {
42258       {
42259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42260       };
42261     }
42262   }
42263   jresult = result;
42264   return jresult;
42265 }
42266
42267
42268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42269   unsigned int jresult ;
42270   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42271   bool result;
42272
42273   arg1 = (Dali::NativeImageInterface *)jarg1;
42274   {
42275     try {
42276       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42277     } catch (std::out_of_range& e) {
42278       {
42279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42280       };
42281     } catch (std::exception& e) {
42282       {
42283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42284       };
42285     } catch (...) {
42286       {
42287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42288       };
42289     }
42290   }
42291   jresult = result;
42292   return jresult;
42293 }
42294
42295
42296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42297   void * jresult ;
42298   std::string *arg1 = 0 ;
42299   Dali::ImageDimensions result;
42300
42301   if (!jarg1) {
42302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42303     return 0;
42304   }
42305   std::string arg1_str(jarg1);
42306   arg1 = &arg1_str;
42307   {
42308     try {
42309       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42310     } catch (std::out_of_range& e) {
42311       {
42312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42313       };
42314     } catch (std::exception& e) {
42315       {
42316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42317       };
42318     } catch (...) {
42319       {
42320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42321       };
42322     }
42323   }
42324   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42325
42326   //argout typemap for const std::string&
42327
42328   return jresult;
42329 }
42330
42331
42332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42333   void * jresult ;
42334   Dali::ResourceImage *result = 0 ;
42335
42336   {
42337     try {
42338       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42339     } catch (std::out_of_range& e) {
42340       {
42341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42342       };
42343     } catch (std::exception& e) {
42344       {
42345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42346       };
42347     } catch (...) {
42348       {
42349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42350       };
42351     }
42352   }
42353   jresult = (void *)result;
42354   return jresult;
42355 }
42356
42357
42358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42359   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42360
42361   arg1 = (Dali::ResourceImage *)jarg1;
42362   {
42363     try {
42364       delete arg1;
42365     } catch (std::out_of_range& e) {
42366       {
42367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42368       };
42369     } catch (std::exception& e) {
42370       {
42371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42372       };
42373     } catch (...) {
42374       {
42375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42376       };
42377     }
42378   }
42379 }
42380
42381
42382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42383   void * jresult ;
42384   Dali::ResourceImage *arg1 = 0 ;
42385   Dali::ResourceImage *result = 0 ;
42386
42387   arg1 = (Dali::ResourceImage *)jarg1;
42388   if (!arg1) {
42389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42390     return 0;
42391   }
42392   {
42393     try {
42394       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42395     } catch (std::out_of_range& e) {
42396       {
42397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42398       };
42399     } catch (std::exception& e) {
42400       {
42401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42402       };
42403     } catch (...) {
42404       {
42405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42406       };
42407     }
42408   }
42409   jresult = (void *)result;
42410   return jresult;
42411 }
42412
42413
42414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42415   void * jresult ;
42416   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42417   Dali::ResourceImage *arg2 = 0 ;
42418   Dali::ResourceImage *result = 0 ;
42419
42420   arg1 = (Dali::ResourceImage *)jarg1;
42421   arg2 = (Dali::ResourceImage *)jarg2;
42422   if (!arg2) {
42423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42424     return 0;
42425   }
42426   {
42427     try {
42428       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42429     } catch (std::out_of_range& e) {
42430       {
42431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42432       };
42433     } catch (std::exception& e) {
42434       {
42435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42436       };
42437     } catch (...) {
42438       {
42439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42440       };
42441     }
42442   }
42443   jresult = (void *)result;
42444   return jresult;
42445 }
42446
42447
42448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42449   void * jresult ;
42450   std::string *arg1 = 0 ;
42451   bool arg2 ;
42452   Dali::ResourceImage result;
42453
42454   if (!jarg1) {
42455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42456     return 0;
42457   }
42458   std::string arg1_str(jarg1);
42459   arg1 = &arg1_str;
42460   arg2 = jarg2 ? true : false;
42461   {
42462     try {
42463       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42464     } catch (std::out_of_range& e) {
42465       {
42466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42467       };
42468     } catch (std::exception& e) {
42469       {
42470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42471       };
42472     } catch (...) {
42473       {
42474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42475       };
42476     }
42477   }
42478   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42479
42480   //argout typemap for const std::string&
42481
42482   return jresult;
42483 }
42484
42485
42486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42487   void * jresult ;
42488   std::string *arg1 = 0 ;
42489   Dali::ResourceImage result;
42490
42491   if (!jarg1) {
42492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42493     return 0;
42494   }
42495   std::string arg1_str(jarg1);
42496   arg1 = &arg1_str;
42497   {
42498     try {
42499       result = Dali::ResourceImage::New((std::string const &)*arg1);
42500     } catch (std::out_of_range& e) {
42501       {
42502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42503       };
42504     } catch (std::exception& e) {
42505       {
42506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42507       };
42508     } catch (...) {
42509       {
42510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42511       };
42512     }
42513   }
42514   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42515
42516   //argout typemap for const std::string&
42517
42518   return jresult;
42519 }
42520
42521
42522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42523   void * jresult ;
42524   std::string *arg1 = 0 ;
42525   Dali::ImageDimensions arg2 ;
42526   Dali::FittingMode::Type arg3 ;
42527   Dali::SamplingMode::Type arg4 ;
42528   bool arg5 ;
42529   Dali::ImageDimensions *argp2 ;
42530   Dali::ResourceImage result;
42531
42532   if (!jarg1) {
42533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42534     return 0;
42535   }
42536   std::string arg1_str(jarg1);
42537   arg1 = &arg1_str;
42538   argp2 = (Dali::ImageDimensions *)jarg2;
42539   if (!argp2) {
42540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42541     return 0;
42542   }
42543   arg2 = *argp2;
42544   arg3 = (Dali::FittingMode::Type)jarg3;
42545   arg4 = (Dali::SamplingMode::Type)jarg4;
42546   arg5 = jarg5 ? true : false;
42547   {
42548     try {
42549       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42550     } catch (std::out_of_range& e) {
42551       {
42552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42553       };
42554     } catch (std::exception& e) {
42555       {
42556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42557       };
42558     } catch (...) {
42559       {
42560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42561       };
42562     }
42563   }
42564   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42565
42566   //argout typemap for const std::string&
42567
42568   return jresult;
42569 }
42570
42571
42572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42573   void * jresult ;
42574   std::string *arg1 = 0 ;
42575   Dali::ImageDimensions arg2 ;
42576   Dali::FittingMode::Type arg3 ;
42577   Dali::SamplingMode::Type arg4 ;
42578   Dali::ImageDimensions *argp2 ;
42579   Dali::ResourceImage result;
42580
42581   if (!jarg1) {
42582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42583     return 0;
42584   }
42585   std::string arg1_str(jarg1);
42586   arg1 = &arg1_str;
42587   argp2 = (Dali::ImageDimensions *)jarg2;
42588   if (!argp2) {
42589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42590     return 0;
42591   }
42592   arg2 = *argp2;
42593   arg3 = (Dali::FittingMode::Type)jarg3;
42594   arg4 = (Dali::SamplingMode::Type)jarg4;
42595   {
42596     try {
42597       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42598     } catch (std::out_of_range& e) {
42599       {
42600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42601       };
42602     } catch (std::exception& e) {
42603       {
42604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42605       };
42606     } catch (...) {
42607       {
42608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42609       };
42610     }
42611   }
42612   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42613
42614   //argout typemap for const std::string&
42615
42616   return jresult;
42617 }
42618
42619
42620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42621   void * jresult ;
42622   std::string *arg1 = 0 ;
42623   Dali::ImageDimensions arg2 ;
42624   Dali::FittingMode::Type arg3 ;
42625   Dali::ImageDimensions *argp2 ;
42626   Dali::ResourceImage result;
42627
42628   if (!jarg1) {
42629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42630     return 0;
42631   }
42632   std::string arg1_str(jarg1);
42633   arg1 = &arg1_str;
42634   argp2 = (Dali::ImageDimensions *)jarg2;
42635   if (!argp2) {
42636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42637     return 0;
42638   }
42639   arg2 = *argp2;
42640   arg3 = (Dali::FittingMode::Type)jarg3;
42641   {
42642     try {
42643       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42644     } catch (std::out_of_range& e) {
42645       {
42646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42647       };
42648     } catch (std::exception& e) {
42649       {
42650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42651       };
42652     } catch (...) {
42653       {
42654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42655       };
42656     }
42657   }
42658   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42659
42660   //argout typemap for const std::string&
42661
42662   return jresult;
42663 }
42664
42665
42666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42667   void * jresult ;
42668   std::string *arg1 = 0 ;
42669   Dali::ImageDimensions arg2 ;
42670   Dali::ImageDimensions *argp2 ;
42671   Dali::ResourceImage result;
42672
42673   if (!jarg1) {
42674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42675     return 0;
42676   }
42677   std::string arg1_str(jarg1);
42678   arg1 = &arg1_str;
42679   argp2 = (Dali::ImageDimensions *)jarg2;
42680   if (!argp2) {
42681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42682     return 0;
42683   }
42684   arg2 = *argp2;
42685   {
42686     try {
42687       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42688     } catch (std::out_of_range& e) {
42689       {
42690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42691       };
42692     } catch (std::exception& e) {
42693       {
42694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42695       };
42696     } catch (...) {
42697       {
42698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42699       };
42700     }
42701   }
42702   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42703
42704   //argout typemap for const std::string&
42705
42706   return jresult;
42707 }
42708
42709
42710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42711   void * jresult ;
42712   Dali::BaseHandle arg1 ;
42713   Dali::BaseHandle *argp1 ;
42714   Dali::ResourceImage result;
42715
42716   argp1 = (Dali::BaseHandle *)jarg1;
42717   if (!argp1) {
42718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42719     return 0;
42720   }
42721   arg1 = *argp1;
42722   {
42723     try {
42724       result = Dali::ResourceImage::DownCast(arg1);
42725     } catch (std::out_of_range& e) {
42726       {
42727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42728       };
42729     } catch (std::exception& e) {
42730       {
42731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42732       };
42733     } catch (...) {
42734       {
42735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42736       };
42737     }
42738   }
42739   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42740   return jresult;
42741 }
42742
42743
42744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42745   int jresult ;
42746   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42747   Dali::LoadingState result;
42748
42749   arg1 = (Dali::ResourceImage *)jarg1;
42750   {
42751     try {
42752       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42753     } catch (std::out_of_range& e) {
42754       {
42755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42756       };
42757     } catch (std::exception& e) {
42758       {
42759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42760       };
42761     } catch (...) {
42762       {
42763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42764       };
42765     }
42766   }
42767   jresult = (int)result;
42768   return jresult;
42769 }
42770
42771
42772 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42773   char * jresult ;
42774   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42775   std::string result;
42776
42777   arg1 = (Dali::ResourceImage *)jarg1;
42778   {
42779     try {
42780       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42781     } catch (std::out_of_range& e) {
42782       {
42783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42784       };
42785     } catch (std::exception& e) {
42786       {
42787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42788       };
42789     } catch (...) {
42790       {
42791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42792       };
42793     }
42794   }
42795   jresult = SWIG_csharp_string_callback((&result)->c_str());
42796   return jresult;
42797 }
42798
42799
42800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42801   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42802
42803   arg1 = (Dali::ResourceImage *)jarg1;
42804   {
42805     try {
42806       (arg1)->Reload();
42807     } catch (std::out_of_range& e) {
42808       {
42809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42810       };
42811     } catch (std::exception& e) {
42812       {
42813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42814       };
42815     } catch (...) {
42816       {
42817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42818       };
42819     }
42820   }
42821 }
42822
42823
42824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
42825   void * jresult ;
42826   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42827   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
42828
42829   arg1 = (Dali::ResourceImage *)jarg1;
42830   {
42831     try {
42832       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
42833     } catch (std::out_of_range& e) {
42834       {
42835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42836       };
42837     } catch (std::exception& e) {
42838       {
42839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42840       };
42841     } catch (...) {
42842       {
42843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42844       };
42845     }
42846   }
42847   jresult = (void *)result;
42848   return jresult;
42849 }
42850
42851
42852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
42853   void * jresult ;
42854   Dali::FrameBufferImage *result = 0 ;
42855
42856   {
42857     try {
42858       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
42859     } catch (std::out_of_range& e) {
42860       {
42861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42862       };
42863     } catch (std::exception& e) {
42864       {
42865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42866       };
42867     } catch (...) {
42868       {
42869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42870       };
42871     }
42872   }
42873   jresult = (void *)result;
42874   return jresult;
42875 }
42876
42877
42878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
42879   void * jresult ;
42880   unsigned int arg1 ;
42881   unsigned int arg2 ;
42882   Dali::Pixel::Format arg3 ;
42883   Dali::RenderBuffer::Format arg4 ;
42884   Dali::FrameBufferImage result;
42885
42886   arg1 = (unsigned int)jarg1;
42887   arg2 = (unsigned int)jarg2;
42888   arg3 = (Dali::Pixel::Format)jarg3;
42889   arg4 = (Dali::RenderBuffer::Format)jarg4;
42890   {
42891     try {
42892       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
42893     } catch (std::out_of_range& e) {
42894       {
42895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42896       };
42897     } catch (std::exception& e) {
42898       {
42899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42900       };
42901     } catch (...) {
42902       {
42903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42904       };
42905     }
42906   }
42907   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42908   return jresult;
42909 }
42910
42911
42912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
42913   void * jresult ;
42914   unsigned int arg1 ;
42915   unsigned int arg2 ;
42916   Dali::Pixel::Format arg3 ;
42917   Dali::FrameBufferImage result;
42918
42919   arg1 = (unsigned int)jarg1;
42920   arg2 = (unsigned int)jarg2;
42921   arg3 = (Dali::Pixel::Format)jarg3;
42922   {
42923     try {
42924       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
42925     } catch (std::out_of_range& e) {
42926       {
42927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42928       };
42929     } catch (std::exception& e) {
42930       {
42931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42932       };
42933     } catch (...) {
42934       {
42935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42936       };
42937     }
42938   }
42939   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42940   return jresult;
42941 }
42942
42943
42944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
42945   void * jresult ;
42946   unsigned int arg1 ;
42947   unsigned int arg2 ;
42948   Dali::FrameBufferImage result;
42949
42950   arg1 = (unsigned int)jarg1;
42951   arg2 = (unsigned int)jarg2;
42952   {
42953     try {
42954       result = Dali::FrameBufferImage::New(arg1,arg2);
42955     } catch (std::out_of_range& e) {
42956       {
42957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42958       };
42959     } catch (std::exception& e) {
42960       {
42961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42962       };
42963     } catch (...) {
42964       {
42965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42966       };
42967     }
42968   }
42969   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42970   return jresult;
42971 }
42972
42973
42974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
42975   void * jresult ;
42976   unsigned int arg1 ;
42977   Dali::FrameBufferImage result;
42978
42979   arg1 = (unsigned int)jarg1;
42980   {
42981     try {
42982       result = Dali::FrameBufferImage::New(arg1);
42983     } catch (std::out_of_range& e) {
42984       {
42985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42986       };
42987     } catch (std::exception& e) {
42988       {
42989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42990       };
42991     } catch (...) {
42992       {
42993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42994       };
42995     }
42996   }
42997   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
42998   return jresult;
42999 }
43000
43001
43002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43003   void * jresult ;
43004   Dali::FrameBufferImage result;
43005
43006   {
43007     try {
43008       result = Dali::FrameBufferImage::New();
43009     } catch (std::out_of_range& e) {
43010       {
43011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43012       };
43013     } catch (std::exception& e) {
43014       {
43015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43016       };
43017     } catch (...) {
43018       {
43019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43020       };
43021     }
43022   }
43023   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43024   return jresult;
43025 }
43026
43027
43028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43029   void * jresult ;
43030   Dali::NativeImageInterface *arg1 = 0 ;
43031   Dali::FrameBufferImage result;
43032
43033   arg1 = (Dali::NativeImageInterface *)jarg1;
43034   if (!arg1) {
43035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43036     return 0;
43037   }
43038   {
43039     try {
43040       result = Dali::FrameBufferImage::New(*arg1);
43041     } catch (std::out_of_range& e) {
43042       {
43043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43044       };
43045     } catch (std::exception& e) {
43046       {
43047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43048       };
43049     } catch (...) {
43050       {
43051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43052       };
43053     }
43054   }
43055   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43056   return jresult;
43057 }
43058
43059
43060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43061   void * jresult ;
43062   Dali::BaseHandle arg1 ;
43063   Dali::BaseHandle *argp1 ;
43064   Dali::FrameBufferImage result;
43065
43066   argp1 = (Dali::BaseHandle *)jarg1;
43067   if (!argp1) {
43068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43069     return 0;
43070   }
43071   arg1 = *argp1;
43072   {
43073     try {
43074       result = Dali::FrameBufferImage::DownCast(arg1);
43075     } catch (std::out_of_range& e) {
43076       {
43077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43078       };
43079     } catch (std::exception& e) {
43080       {
43081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43082       };
43083     } catch (...) {
43084       {
43085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43086       };
43087     }
43088   }
43089   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43090   return jresult;
43091 }
43092
43093
43094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43095   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43096
43097   arg1 = (Dali::FrameBufferImage *)jarg1;
43098   {
43099     try {
43100       delete arg1;
43101     } catch (std::out_of_range& e) {
43102       {
43103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43104       };
43105     } catch (std::exception& e) {
43106       {
43107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43108       };
43109     } catch (...) {
43110       {
43111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43112       };
43113     }
43114   }
43115 }
43116
43117
43118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43119   void * jresult ;
43120   Dali::FrameBufferImage *arg1 = 0 ;
43121   Dali::FrameBufferImage *result = 0 ;
43122
43123   arg1 = (Dali::FrameBufferImage *)jarg1;
43124   if (!arg1) {
43125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43126     return 0;
43127   }
43128   {
43129     try {
43130       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43131     } catch (std::out_of_range& e) {
43132       {
43133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43134       };
43135     } catch (std::exception& e) {
43136       {
43137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43138       };
43139     } catch (...) {
43140       {
43141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43142       };
43143     }
43144   }
43145   jresult = (void *)result;
43146   return jresult;
43147 }
43148
43149
43150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43151   void * jresult ;
43152   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43153   Dali::FrameBufferImage *arg2 = 0 ;
43154   Dali::FrameBufferImage *result = 0 ;
43155
43156   arg1 = (Dali::FrameBufferImage *)jarg1;
43157   arg2 = (Dali::FrameBufferImage *)jarg2;
43158   if (!arg2) {
43159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43160     return 0;
43161   }
43162   {
43163     try {
43164       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43165     } catch (std::out_of_range& e) {
43166       {
43167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43168       };
43169     } catch (std::exception& e) {
43170       {
43171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43172       };
43173     } catch (...) {
43174       {
43175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43176       };
43177     }
43178   }
43179   jresult = (void *)result;
43180   return jresult;
43181 }
43182
43183
43184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43185   void * jresult ;
43186   Dali::NinePatchImage *result = 0 ;
43187
43188   {
43189     try {
43190       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43191     } catch (std::out_of_range& e) {
43192       {
43193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43194       };
43195     } catch (std::exception& e) {
43196       {
43197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43198       };
43199     } catch (...) {
43200       {
43201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43202       };
43203     }
43204   }
43205   jresult = (void *)result;
43206   return jresult;
43207 }
43208
43209
43210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43211   void * jresult ;
43212   std::string *arg1 = 0 ;
43213   Dali::NinePatchImage result;
43214
43215   if (!jarg1) {
43216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43217     return 0;
43218   }
43219   std::string arg1_str(jarg1);
43220   arg1 = &arg1_str;
43221   {
43222     try {
43223       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43224     } catch (std::out_of_range& e) {
43225       {
43226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43227       };
43228     } catch (std::exception& e) {
43229       {
43230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43231       };
43232     } catch (...) {
43233       {
43234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43235       };
43236     }
43237   }
43238   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43239
43240   //argout typemap for const std::string&
43241
43242   return jresult;
43243 }
43244
43245
43246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43247   void * jresult ;
43248   Dali::BaseHandle arg1 ;
43249   Dali::BaseHandle *argp1 ;
43250   Dali::NinePatchImage result;
43251
43252   argp1 = (Dali::BaseHandle *)jarg1;
43253   if (!argp1) {
43254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43255     return 0;
43256   }
43257   arg1 = *argp1;
43258   {
43259     try {
43260       result = Dali::NinePatchImage::DownCast(arg1);
43261     } catch (std::out_of_range& e) {
43262       {
43263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43264       };
43265     } catch (std::exception& e) {
43266       {
43267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43268       };
43269     } catch (...) {
43270       {
43271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43272       };
43273     }
43274   }
43275   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43276   return jresult;
43277 }
43278
43279
43280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43281   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43282
43283   arg1 = (Dali::NinePatchImage *)jarg1;
43284   {
43285     try {
43286       delete arg1;
43287     } catch (std::out_of_range& e) {
43288       {
43289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43290       };
43291     } catch (std::exception& e) {
43292       {
43293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43294       };
43295     } catch (...) {
43296       {
43297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43298       };
43299     }
43300   }
43301 }
43302
43303
43304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43305   void * jresult ;
43306   Dali::NinePatchImage *arg1 = 0 ;
43307   Dali::NinePatchImage *result = 0 ;
43308
43309   arg1 = (Dali::NinePatchImage *)jarg1;
43310   if (!arg1) {
43311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43312     return 0;
43313   }
43314   {
43315     try {
43316       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43317     } catch (std::out_of_range& e) {
43318       {
43319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43320       };
43321     } catch (std::exception& e) {
43322       {
43323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43324       };
43325     } catch (...) {
43326       {
43327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43328       };
43329     }
43330   }
43331   jresult = (void *)result;
43332   return jresult;
43333 }
43334
43335
43336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43337   void * jresult ;
43338   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43339   Dali::NinePatchImage *arg2 = 0 ;
43340   Dali::NinePatchImage *result = 0 ;
43341
43342   arg1 = (Dali::NinePatchImage *)jarg1;
43343   arg2 = (Dali::NinePatchImage *)jarg2;
43344   if (!arg2) {
43345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43346     return 0;
43347   }
43348   {
43349     try {
43350       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43351     } catch (std::out_of_range& e) {
43352       {
43353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43354       };
43355     } catch (std::exception& e) {
43356       {
43357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43358       };
43359     } catch (...) {
43360       {
43361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43362       };
43363     }
43364   }
43365   jresult = (void *)result;
43366   return jresult;
43367 }
43368
43369
43370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43371   void * jresult ;
43372   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43373   Dali::Vector4 result;
43374
43375   arg1 = (Dali::NinePatchImage *)jarg1;
43376   {
43377     try {
43378       result = (arg1)->GetStretchBorders();
43379     } catch (std::out_of_range& e) {
43380       {
43381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43382       };
43383     } catch (std::exception& e) {
43384       {
43385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43386       };
43387     } catch (...) {
43388       {
43389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43390       };
43391     }
43392   }
43393   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43394   return jresult;
43395 }
43396
43397
43398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43399   void * jresult ;
43400   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43401   Dali::NinePatchImage::StretchRanges *result = 0 ;
43402
43403   arg1 = (Dali::NinePatchImage *)jarg1;
43404   {
43405     try {
43406       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43407     } catch (std::out_of_range& e) {
43408       {
43409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43410       };
43411     } catch (std::exception& e) {
43412       {
43413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43414       };
43415     } catch (...) {
43416       {
43417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43418       };
43419     }
43420   }
43421   jresult = (void *)result;
43422   return jresult;
43423 }
43424
43425
43426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43427   void * jresult ;
43428   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43429   Dali::NinePatchImage::StretchRanges *result = 0 ;
43430
43431   arg1 = (Dali::NinePatchImage *)jarg1;
43432   {
43433     try {
43434       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43435     } catch (std::out_of_range& e) {
43436       {
43437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43438       };
43439     } catch (std::exception& e) {
43440       {
43441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43442       };
43443     } catch (...) {
43444       {
43445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43446       };
43447     }
43448   }
43449   jresult = (void *)result;
43450   return jresult;
43451 }
43452
43453
43454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43455   void * jresult ;
43456   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43457   Dali::Rect< int > result;
43458
43459   arg1 = (Dali::NinePatchImage *)jarg1;
43460   {
43461     try {
43462       result = (arg1)->GetChildRectangle();
43463     } catch (std::out_of_range& e) {
43464       {
43465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43466       };
43467     } catch (std::exception& e) {
43468       {
43469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43470       };
43471     } catch (...) {
43472       {
43473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43474       };
43475     }
43476   }
43477   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43478   return jresult;
43479 }
43480
43481
43482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43483   void * jresult ;
43484   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43485   Dali::BufferImage result;
43486
43487   arg1 = (Dali::NinePatchImage *)jarg1;
43488   {
43489     try {
43490       result = (arg1)->CreateCroppedBufferImage();
43491     } catch (std::out_of_range& e) {
43492       {
43493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43494       };
43495     } catch (std::exception& e) {
43496       {
43497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43498       };
43499     } catch (...) {
43500       {
43501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43502       };
43503     }
43504   }
43505   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43506   return jresult;
43507 }
43508
43509
43510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43511   unsigned int jresult ;
43512   std::string *arg1 = 0 ;
43513   bool result;
43514
43515   if (!jarg1) {
43516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43517     return 0;
43518   }
43519   std::string arg1_str(jarg1);
43520   arg1 = &arg1_str;
43521   {
43522     try {
43523       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43524     } catch (std::out_of_range& e) {
43525       {
43526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43527       };
43528     } catch (std::exception& e) {
43529       {
43530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43531       };
43532     } catch (...) {
43533       {
43534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43535       };
43536     }
43537   }
43538   jresult = result;
43539
43540   //argout typemap for const std::string&
43541
43542   return jresult;
43543 }
43544
43545
43546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43547   int jresult ;
43548   int result;
43549
43550   result = (int)Dali::CameraActor::Property::TYPE;
43551   jresult = (int)result;
43552   return jresult;
43553 }
43554
43555
43556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43557   int jresult ;
43558   int result;
43559
43560   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43561   jresult = (int)result;
43562   return jresult;
43563 }
43564
43565
43566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43567   int jresult ;
43568   int result;
43569
43570   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43571   jresult = (int)result;
43572   return jresult;
43573 }
43574
43575
43576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43577   int jresult ;
43578   int result;
43579
43580   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43581   jresult = (int)result;
43582   return jresult;
43583 }
43584
43585
43586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43587   int jresult ;
43588   int result;
43589
43590   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43591   jresult = (int)result;
43592   return jresult;
43593 }
43594
43595
43596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43597   int jresult ;
43598   int result;
43599
43600   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43601   jresult = (int)result;
43602   return jresult;
43603 }
43604
43605
43606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43607   int jresult ;
43608   int result;
43609
43610   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43611   jresult = (int)result;
43612   return jresult;
43613 }
43614
43615
43616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43617   int jresult ;
43618   int result;
43619
43620   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43621   jresult = (int)result;
43622   return jresult;
43623 }
43624
43625
43626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43627   int jresult ;
43628   int result;
43629
43630   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43631   jresult = (int)result;
43632   return jresult;
43633 }
43634
43635
43636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43637   int jresult ;
43638   int result;
43639
43640   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43641   jresult = (int)result;
43642   return jresult;
43643 }
43644
43645
43646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43647   int jresult ;
43648   int result;
43649
43650   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43651   jresult = (int)result;
43652   return jresult;
43653 }
43654
43655
43656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43657   int jresult ;
43658   int result;
43659
43660   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43661   jresult = (int)result;
43662   return jresult;
43663 }
43664
43665
43666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43667   int jresult ;
43668   int result;
43669
43670   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43671   jresult = (int)result;
43672   return jresult;
43673 }
43674
43675
43676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43677   int jresult ;
43678   int result;
43679
43680   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43681   jresult = (int)result;
43682   return jresult;
43683 }
43684
43685
43686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43687   void * jresult ;
43688   Dali::CameraActor::Property *result = 0 ;
43689
43690   {
43691     try {
43692       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
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 (...) {
43702       {
43703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43704       };
43705     }
43706   }
43707   jresult = (void *)result;
43708   return jresult;
43709 }
43710
43711
43712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43713   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43714
43715   arg1 = (Dali::CameraActor::Property *)jarg1;
43716   {
43717     try {
43718       delete arg1;
43719     } catch (std::out_of_range& e) {
43720       {
43721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43722       };
43723     } catch (std::exception& e) {
43724       {
43725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43726       };
43727     } catch (...) {
43728       {
43729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43730       };
43731     }
43732   }
43733 }
43734
43735
43736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43737   void * jresult ;
43738   Dali::CameraActor *result = 0 ;
43739
43740   {
43741     try {
43742       result = (Dali::CameraActor *)new Dali::CameraActor();
43743     } catch (std::out_of_range& e) {
43744       {
43745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43746       };
43747     } catch (std::exception& e) {
43748       {
43749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43750       };
43751     } catch (...) {
43752       {
43753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43754       };
43755     }
43756   }
43757   jresult = (void *)result;
43758   return jresult;
43759 }
43760
43761
43762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43763   void * jresult ;
43764   Dali::CameraActor result;
43765
43766   {
43767     try {
43768       result = Dali::CameraActor::New();
43769     } catch (std::out_of_range& e) {
43770       {
43771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43772       };
43773     } catch (std::exception& e) {
43774       {
43775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43776       };
43777     } catch (...) {
43778       {
43779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43780       };
43781     }
43782   }
43783   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43784   return jresult;
43785 }
43786
43787
43788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43789   void * jresult ;
43790   Dali::Size *arg1 = 0 ;
43791   Dali::CameraActor result;
43792
43793   arg1 = (Dali::Size *)jarg1;
43794   if (!arg1) {
43795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43796     return 0;
43797   }
43798   {
43799     try {
43800       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43801     } catch (std::out_of_range& e) {
43802       {
43803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43804       };
43805     } catch (std::exception& e) {
43806       {
43807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43808       };
43809     } catch (...) {
43810       {
43811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43812       };
43813     }
43814   }
43815   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43816   return jresult;
43817 }
43818
43819
43820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
43821   void * jresult ;
43822   Dali::BaseHandle arg1 ;
43823   Dali::BaseHandle *argp1 ;
43824   Dali::CameraActor result;
43825
43826   argp1 = (Dali::BaseHandle *)jarg1;
43827   if (!argp1) {
43828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43829     return 0;
43830   }
43831   arg1 = *argp1;
43832   {
43833     try {
43834       result = Dali::CameraActor::DownCast(arg1);
43835     } catch (std::out_of_range& e) {
43836       {
43837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43838       };
43839     } catch (std::exception& e) {
43840       {
43841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43842       };
43843     } catch (...) {
43844       {
43845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43846       };
43847     }
43848   }
43849   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43850   return jresult;
43851 }
43852
43853
43854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
43855   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43856
43857   arg1 = (Dali::CameraActor *)jarg1;
43858   {
43859     try {
43860       delete arg1;
43861     } catch (std::out_of_range& e) {
43862       {
43863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43864       };
43865     } catch (std::exception& e) {
43866       {
43867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43868       };
43869     } catch (...) {
43870       {
43871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43872       };
43873     }
43874   }
43875 }
43876
43877
43878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
43879   void * jresult ;
43880   Dali::CameraActor *arg1 = 0 ;
43881   Dali::CameraActor *result = 0 ;
43882
43883   arg1 = (Dali::CameraActor *)jarg1;
43884   if (!arg1) {
43885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43886     return 0;
43887   }
43888   {
43889     try {
43890       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
43891     } catch (std::out_of_range& e) {
43892       {
43893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43894       };
43895     } catch (std::exception& e) {
43896       {
43897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43898       };
43899     } catch (...) {
43900       {
43901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43902       };
43903     }
43904   }
43905   jresult = (void *)result;
43906   return jresult;
43907 }
43908
43909
43910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
43911   void * jresult ;
43912   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43913   Dali::CameraActor *arg2 = 0 ;
43914   Dali::CameraActor *result = 0 ;
43915
43916   arg1 = (Dali::CameraActor *)jarg1;
43917   arg2 = (Dali::CameraActor *)jarg2;
43918   if (!arg2) {
43919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
43920     return 0;
43921   }
43922   {
43923     try {
43924       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
43925     } catch (std::out_of_range& e) {
43926       {
43927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43928       };
43929     } catch (std::exception& e) {
43930       {
43931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43932       };
43933     } catch (...) {
43934       {
43935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43936       };
43937     }
43938   }
43939   jresult = (void *)result;
43940   return jresult;
43941 }
43942
43943
43944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
43945   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43946   Dali::Camera::Type arg2 ;
43947
43948   arg1 = (Dali::CameraActor *)jarg1;
43949   arg2 = (Dali::Camera::Type)jarg2;
43950   {
43951     try {
43952       (arg1)->SetType(arg2);
43953     } catch (std::out_of_range& e) {
43954       {
43955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43956       };
43957     } catch (std::exception& e) {
43958       {
43959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43960       };
43961     } catch (...) {
43962       {
43963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43964       };
43965     }
43966   }
43967 }
43968
43969
43970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
43971   int jresult ;
43972   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
43973   Dali::Camera::Type result;
43974
43975   arg1 = (Dali::CameraActor *)jarg1;
43976   {
43977     try {
43978       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
43979     } catch (std::out_of_range& e) {
43980       {
43981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43982       };
43983     } catch (std::exception& e) {
43984       {
43985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43986       };
43987     } catch (...) {
43988       {
43989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43990       };
43991     }
43992   }
43993   jresult = (int)result;
43994   return jresult;
43995 }
43996
43997
43998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
43999   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44000   Dali::Camera::ProjectionMode arg2 ;
44001
44002   arg1 = (Dali::CameraActor *)jarg1;
44003   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44004   {
44005     try {
44006       (arg1)->SetProjectionMode(arg2);
44007     } catch (std::out_of_range& e) {
44008       {
44009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44010       };
44011     } catch (std::exception& e) {
44012       {
44013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44014       };
44015     } catch (...) {
44016       {
44017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44018       };
44019     }
44020   }
44021 }
44022
44023
44024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44025   int jresult ;
44026   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44027   Dali::Camera::ProjectionMode result;
44028
44029   arg1 = (Dali::CameraActor *)jarg1;
44030   {
44031     try {
44032       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44033     } catch (std::out_of_range& e) {
44034       {
44035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44036       };
44037     } catch (std::exception& e) {
44038       {
44039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44040       };
44041     } catch (...) {
44042       {
44043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44044       };
44045     }
44046   }
44047   jresult = (int)result;
44048   return jresult;
44049 }
44050
44051
44052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44053   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44054   float arg2 ;
44055
44056   arg1 = (Dali::CameraActor *)jarg1;
44057   arg2 = (float)jarg2;
44058   {
44059     try {
44060       (arg1)->SetFieldOfView(arg2);
44061     } catch (std::out_of_range& e) {
44062       {
44063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44064       };
44065     } catch (std::exception& e) {
44066       {
44067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44068       };
44069     } catch (...) {
44070       {
44071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44072       };
44073     }
44074   }
44075 }
44076
44077
44078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44079   float jresult ;
44080   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44081   float result;
44082
44083   arg1 = (Dali::CameraActor *)jarg1;
44084   {
44085     try {
44086       result = (float)(arg1)->GetFieldOfView();
44087     } catch (std::out_of_range& e) {
44088       {
44089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44090       };
44091     } catch (std::exception& e) {
44092       {
44093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44094       };
44095     } catch (...) {
44096       {
44097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44098       };
44099     }
44100   }
44101   jresult = result;
44102   return jresult;
44103 }
44104
44105
44106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44107   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44108   float arg2 ;
44109
44110   arg1 = (Dali::CameraActor *)jarg1;
44111   arg2 = (float)jarg2;
44112   {
44113     try {
44114       (arg1)->SetAspectRatio(arg2);
44115     } catch (std::out_of_range& e) {
44116       {
44117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44118       };
44119     } catch (std::exception& e) {
44120       {
44121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44122       };
44123     } catch (...) {
44124       {
44125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44126       };
44127     }
44128   }
44129 }
44130
44131
44132 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44133   float jresult ;
44134   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44135   float result;
44136
44137   arg1 = (Dali::CameraActor *)jarg1;
44138   {
44139     try {
44140       result = (float)(arg1)->GetAspectRatio();
44141     } catch (std::out_of_range& e) {
44142       {
44143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44144       };
44145     } catch (std::exception& e) {
44146       {
44147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44148       };
44149     } catch (...) {
44150       {
44151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44152       };
44153     }
44154   }
44155   jresult = result;
44156   return jresult;
44157 }
44158
44159
44160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44161   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44162   float arg2 ;
44163
44164   arg1 = (Dali::CameraActor *)jarg1;
44165   arg2 = (float)jarg2;
44166   {
44167     try {
44168       (arg1)->SetNearClippingPlane(arg2);
44169     } catch (std::out_of_range& e) {
44170       {
44171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44172       };
44173     } catch (std::exception& e) {
44174       {
44175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44176       };
44177     } catch (...) {
44178       {
44179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44180       };
44181     }
44182   }
44183 }
44184
44185
44186 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44187   float jresult ;
44188   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44189   float result;
44190
44191   arg1 = (Dali::CameraActor *)jarg1;
44192   {
44193     try {
44194       result = (float)(arg1)->GetNearClippingPlane();
44195     } catch (std::out_of_range& e) {
44196       {
44197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44198       };
44199     } catch (std::exception& e) {
44200       {
44201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44202       };
44203     } catch (...) {
44204       {
44205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44206       };
44207     }
44208   }
44209   jresult = result;
44210   return jresult;
44211 }
44212
44213
44214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44215   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44216   float arg2 ;
44217
44218   arg1 = (Dali::CameraActor *)jarg1;
44219   arg2 = (float)jarg2;
44220   {
44221     try {
44222       (arg1)->SetFarClippingPlane(arg2);
44223     } catch (std::out_of_range& e) {
44224       {
44225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44226       };
44227     } catch (std::exception& e) {
44228       {
44229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44230       };
44231     } catch (...) {
44232       {
44233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44234       };
44235     }
44236   }
44237 }
44238
44239
44240 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44241   float jresult ;
44242   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44243   float result;
44244
44245   arg1 = (Dali::CameraActor *)jarg1;
44246   {
44247     try {
44248       result = (float)(arg1)->GetFarClippingPlane();
44249     } catch (std::out_of_range& e) {
44250       {
44251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44252       };
44253     } catch (std::exception& e) {
44254       {
44255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44256       };
44257     } catch (...) {
44258       {
44259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44260       };
44261     }
44262   }
44263   jresult = result;
44264   return jresult;
44265 }
44266
44267
44268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44269   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44270   Dali::Vector3 *arg2 = 0 ;
44271
44272   arg1 = (Dali::CameraActor *)jarg1;
44273   arg2 = (Dali::Vector3 *)jarg2;
44274   if (!arg2) {
44275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44276     return ;
44277   }
44278   {
44279     try {
44280       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44281     } catch (std::out_of_range& e) {
44282       {
44283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44284       };
44285     } catch (std::exception& e) {
44286       {
44287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44288       };
44289     } catch (...) {
44290       {
44291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44292       };
44293     }
44294   }
44295 }
44296
44297
44298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44299   void * jresult ;
44300   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44301   Dali::Vector3 result;
44302
44303   arg1 = (Dali::CameraActor *)jarg1;
44304   {
44305     try {
44306       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
44307     } catch (std::out_of_range& e) {
44308       {
44309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44310       };
44311     } catch (std::exception& e) {
44312       {
44313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44314       };
44315     } catch (...) {
44316       {
44317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44318       };
44319     }
44320   }
44321   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
44322   return jresult;
44323 }
44324
44325
44326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44327   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44328   bool arg2 ;
44329
44330   arg1 = (Dali::CameraActor *)jarg1;
44331   arg2 = jarg2 ? true : false;
44332   {
44333     try {
44334       (arg1)->SetInvertYAxis(arg2);
44335     } catch (std::out_of_range& e) {
44336       {
44337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44338       };
44339     } catch (std::exception& e) {
44340       {
44341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44342       };
44343     } catch (...) {
44344       {
44345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44346       };
44347     }
44348   }
44349 }
44350
44351
44352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44353   unsigned int jresult ;
44354   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44355   bool result;
44356
44357   arg1 = (Dali::CameraActor *)jarg1;
44358   {
44359     try {
44360       result = (bool)(arg1)->GetInvertYAxis();
44361     } catch (std::out_of_range& e) {
44362       {
44363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44364       };
44365     } catch (std::exception& e) {
44366       {
44367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44368       };
44369     } catch (...) {
44370       {
44371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44372       };
44373     }
44374   }
44375   jresult = result;
44376   return jresult;
44377 }
44378
44379
44380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44381   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44382   Dali::Size *arg2 = 0 ;
44383
44384   arg1 = (Dali::CameraActor *)jarg1;
44385   arg2 = (Dali::Size *)jarg2;
44386   if (!arg2) {
44387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44388     return ;
44389   }
44390   {
44391     try {
44392       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44393     } catch (std::out_of_range& e) {
44394       {
44395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44396       };
44397     } catch (std::exception& e) {
44398       {
44399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44400       };
44401     } catch (...) {
44402       {
44403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44404       };
44405     }
44406   }
44407 }
44408
44409
44410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44411   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44412   Dali::Size *arg2 = 0 ;
44413
44414   arg1 = (Dali::CameraActor *)jarg1;
44415   arg2 = (Dali::Size *)jarg2;
44416   if (!arg2) {
44417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44418     return ;
44419   }
44420   {
44421     try {
44422       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44423     } catch (std::out_of_range& e) {
44424       {
44425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44426       };
44427     } catch (std::exception& e) {
44428       {
44429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44430       };
44431     } catch (...) {
44432       {
44433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44434       };
44435     }
44436   }
44437 }
44438
44439
44440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44441   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44442   float arg2 ;
44443   float arg3 ;
44444   float arg4 ;
44445   float arg5 ;
44446   float arg6 ;
44447   float arg7 ;
44448
44449   arg1 = (Dali::CameraActor *)jarg1;
44450   arg2 = (float)jarg2;
44451   arg3 = (float)jarg3;
44452   arg4 = (float)jarg4;
44453   arg5 = (float)jarg5;
44454   arg6 = (float)jarg6;
44455   arg7 = (float)jarg7;
44456   {
44457     try {
44458       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44459     } catch (std::out_of_range& e) {
44460       {
44461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44462       };
44463     } catch (std::exception& e) {
44464       {
44465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44466       };
44467     } catch (...) {
44468       {
44469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44470       };
44471     }
44472   }
44473 }
44474
44475
44476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44477   void * jresult ;
44478   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44479
44480   {
44481     try {
44482       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44483     } catch (std::out_of_range& e) {
44484       {
44485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44486       };
44487     } catch (std::exception& e) {
44488       {
44489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44490       };
44491     } catch (...) {
44492       {
44493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44494       };
44495     }
44496   }
44497   jresult = (void *)result;
44498   return jresult;
44499 }
44500
44501
44502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44503   void * jresult ;
44504   std::string arg1 ;
44505   Dali::Property::Value arg2 ;
44506   Dali::Property::Value *argp2 ;
44507   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44508
44509   if (!jarg1) {
44510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44511     return 0;
44512   }
44513   (&arg1)->assign(jarg1);
44514   argp2 = (Dali::Property::Value *)jarg2;
44515   if (!argp2) {
44516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44517     return 0;
44518   }
44519   arg2 = *argp2;
44520   {
44521     try {
44522       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44523     } catch (std::out_of_range& e) {
44524       {
44525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44526       };
44527     } catch (std::exception& e) {
44528       {
44529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44530       };
44531     } catch (...) {
44532       {
44533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44534       };
44535     }
44536   }
44537   jresult = (void *)result;
44538   return jresult;
44539 }
44540
44541
44542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44543   void * jresult ;
44544   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44545   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44546
44547   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44548   if (!arg1) {
44549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44550     return 0;
44551   }
44552   {
44553     try {
44554       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);
44555     } catch (std::out_of_range& e) {
44556       {
44557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44558       };
44559     } catch (std::exception& e) {
44560       {
44561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44562       };
44563     } catch (...) {
44564       {
44565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44566       };
44567     }
44568   }
44569   jresult = (void *)result;
44570   return jresult;
44571 }
44572
44573
44574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44575   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44576   std::string *arg2 = 0 ;
44577
44578   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44579   if (!jarg2) {
44580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44581     return ;
44582   }
44583   std::string arg2_str(jarg2);
44584   arg2 = &arg2_str;
44585   if (arg1) (arg1)->first = *arg2;
44586
44587   //argout typemap for const std::string&
44588
44589 }
44590
44591
44592 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44593   char * jresult ;
44594   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44595   std::string *result = 0 ;
44596
44597   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44598   result = (std::string *) & ((arg1)->first);
44599   jresult = SWIG_csharp_string_callback(result->c_str());
44600   return jresult;
44601 }
44602
44603
44604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44605   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44606   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44607
44608   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44609   arg2 = (Dali::Property::Value *)jarg2;
44610   if (arg1) (arg1)->second = *arg2;
44611 }
44612
44613
44614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44615   void * jresult ;
44616   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44617   Dali::Property::Value *result = 0 ;
44618
44619   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44620   result = (Dali::Property::Value *)& ((arg1)->second);
44621   jresult = (void *)result;
44622   return jresult;
44623 }
44624
44625
44626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44627   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44628
44629   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44630   {
44631     try {
44632       delete arg1;
44633     } catch (std::out_of_range& e) {
44634       {
44635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44636       };
44637     } catch (std::exception& e) {
44638       {
44639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44640       };
44641     } catch (...) {
44642       {
44643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44644       };
44645     }
44646   }
44647 }
44648
44649
44650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44651   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44652
44653   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44654   {
44655     try {
44656       (arg1)->clear();
44657     } catch (std::out_of_range& e) {
44658       {
44659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44660       };
44661     } catch (std::exception& e) {
44662       {
44663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44664       };
44665     } catch (...) {
44666       {
44667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44668       };
44669     }
44670   }
44671 }
44672
44673
44674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44675   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44676   Dali::TouchPoint *arg2 = 0 ;
44677
44678   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44679   arg2 = (Dali::TouchPoint *)jarg2;
44680   if (!arg2) {
44681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44682     return ;
44683   }
44684   {
44685     try {
44686       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44687     } catch (std::out_of_range& e) {
44688       {
44689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44690       };
44691     } catch (std::exception& e) {
44692       {
44693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44694       };
44695     } catch (...) {
44696       {
44697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44698       };
44699     }
44700   }
44701 }
44702
44703
44704 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44705   unsigned long jresult ;
44706   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44707   std::vector< Dali::TouchPoint >::size_type result;
44708
44709   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44710   {
44711     try {
44712       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44713     } catch (std::out_of_range& e) {
44714       {
44715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44716       };
44717     } catch (std::exception& e) {
44718       {
44719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44720       };
44721     } catch (...) {
44722       {
44723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44724       };
44725     }
44726   }
44727   jresult = (unsigned long)result;
44728   return jresult;
44729 }
44730
44731
44732 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44733   unsigned long jresult ;
44734   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44735   std::vector< Dali::TouchPoint >::size_type result;
44736
44737   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44738   {
44739     try {
44740       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44741     } catch (std::out_of_range& e) {
44742       {
44743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44744       };
44745     } catch (std::exception& e) {
44746       {
44747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44748       };
44749     } catch (...) {
44750       {
44751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44752       };
44753     }
44754   }
44755   jresult = (unsigned long)result;
44756   return jresult;
44757 }
44758
44759
44760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44761   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44762   std::vector< Dali::TouchPoint >::size_type arg2 ;
44763
44764   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44765   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44766   {
44767     try {
44768       (arg1)->reserve(arg2);
44769     } catch (std::out_of_range& e) {
44770       {
44771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44772       };
44773     } catch (std::exception& e) {
44774       {
44775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44776       };
44777     } catch (...) {
44778       {
44779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44780       };
44781     }
44782   }
44783 }
44784
44785
44786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44787   void * jresult ;
44788   std::vector< Dali::TouchPoint > *result = 0 ;
44789
44790   {
44791     try {
44792       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44793     } catch (std::out_of_range& e) {
44794       {
44795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44796       };
44797     } catch (std::exception& e) {
44798       {
44799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44800       };
44801     } catch (...) {
44802       {
44803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44804       };
44805     }
44806   }
44807   jresult = (void *)result;
44808   return jresult;
44809 }
44810
44811
44812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
44813   void * jresult ;
44814   std::vector< Dali::TouchPoint > *arg1 = 0 ;
44815   std::vector< Dali::TouchPoint > *result = 0 ;
44816
44817   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44818   if (!arg1) {
44819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44820     return 0;
44821   }
44822   {
44823     try {
44824       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
44825     } catch (std::out_of_range& e) {
44826       {
44827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44828       };
44829     } catch (std::exception& e) {
44830       {
44831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44832       };
44833     } catch (...) {
44834       {
44835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44836       };
44837     }
44838   }
44839   jresult = (void *)result;
44840   return jresult;
44841 }
44842
44843
44844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
44845   void * jresult ;
44846   int arg1 ;
44847   std::vector< Dali::TouchPoint > *result = 0 ;
44848
44849   arg1 = (int)jarg1;
44850   {
44851     try {
44852       try {
44853         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
44854       }
44855       catch(std::out_of_range &_e) {
44856         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44857         return 0;
44858       }
44859
44860     } catch (std::out_of_range& e) {
44861       {
44862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44863       };
44864     } catch (std::exception& e) {
44865       {
44866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44867       };
44868     } catch (...) {
44869       {
44870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44871       };
44872     }
44873   }
44874   jresult = (void *)result;
44875   return jresult;
44876 }
44877
44878
44879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
44880   void * jresult ;
44881   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44882   int arg2 ;
44883   SwigValueWrapper< Dali::TouchPoint > result;
44884
44885   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44886   arg2 = (int)jarg2;
44887   {
44888     try {
44889       try {
44890         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
44891       }
44892       catch(std::out_of_range &_e) {
44893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44894         return 0;
44895       }
44896
44897     } catch (std::out_of_range& e) {
44898       {
44899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44900       };
44901     } catch (std::exception& e) {
44902       {
44903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44904       };
44905     } catch (...) {
44906       {
44907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44908       };
44909     }
44910   }
44911   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
44912   return jresult;
44913 }
44914
44915
44916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
44917   void * jresult ;
44918   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44919   int arg2 ;
44920   Dali::TouchPoint *result = 0 ;
44921
44922   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44923   arg2 = (int)jarg2;
44924   {
44925     try {
44926       try {
44927         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
44928       }
44929       catch(std::out_of_range &_e) {
44930         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44931         return 0;
44932       }
44933
44934     } catch (std::out_of_range& e) {
44935       {
44936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44937       };
44938     } catch (std::exception& e) {
44939       {
44940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44941       };
44942     } catch (...) {
44943       {
44944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44945       };
44946     }
44947   }
44948   jresult = (void *)result;
44949   return jresult;
44950 }
44951
44952
44953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
44954   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44955   int arg2 ;
44956   Dali::TouchPoint *arg3 = 0 ;
44957
44958   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44959   arg2 = (int)jarg2;
44960   arg3 = (Dali::TouchPoint *)jarg3;
44961   if (!arg3) {
44962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44963     return ;
44964   }
44965   {
44966     try {
44967       try {
44968         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
44969       }
44970       catch(std::out_of_range &_e) {
44971         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
44972         return ;
44973       }
44974
44975     } catch (std::out_of_range& e) {
44976       {
44977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44978       };
44979     } catch (std::exception& e) {
44980       {
44981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44982       };
44983     } catch (...) {
44984       {
44985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44986       };
44987     }
44988   }
44989 }
44990
44991
44992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
44993   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44994   std::vector< Dali::TouchPoint > *arg2 = 0 ;
44995
44996   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44997   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
44998   if (!arg2) {
44999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45000     return ;
45001   }
45002   {
45003     try {
45004       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45005     } catch (std::out_of_range& e) {
45006       {
45007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45008       };
45009     } catch (std::exception& e) {
45010       {
45011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45012       };
45013     } catch (...) {
45014       {
45015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45016       };
45017     }
45018   }
45019 }
45020
45021
45022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45023   void * jresult ;
45024   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45025   int arg2 ;
45026   int arg3 ;
45027   std::vector< Dali::TouchPoint > *result = 0 ;
45028
45029   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45030   arg2 = (int)jarg2;
45031   arg3 = (int)jarg3;
45032   {
45033     try {
45034       try {
45035         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45036       }
45037       catch(std::out_of_range &_e) {
45038         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45039         return 0;
45040       }
45041       catch(std::invalid_argument &_e) {
45042         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45043         return 0;
45044       }
45045
45046     } catch (std::out_of_range& e) {
45047       {
45048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45049       };
45050     } catch (std::exception& e) {
45051       {
45052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45053       };
45054     } catch (...) {
45055       {
45056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45057       };
45058     }
45059   }
45060   jresult = (void *)result;
45061   return jresult;
45062 }
45063
45064
45065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45066   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45067   int arg2 ;
45068   Dali::TouchPoint *arg3 = 0 ;
45069
45070   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45071   arg2 = (int)jarg2;
45072   arg3 = (Dali::TouchPoint *)jarg3;
45073   if (!arg3) {
45074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45075     return ;
45076   }
45077   {
45078     try {
45079       try {
45080         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45081       }
45082       catch(std::out_of_range &_e) {
45083         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45084         return ;
45085       }
45086
45087     } catch (std::out_of_range& e) {
45088       {
45089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45090       };
45091     } catch (std::exception& e) {
45092       {
45093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45094       };
45095     } catch (...) {
45096       {
45097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45098       };
45099     }
45100   }
45101 }
45102
45103
45104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45105   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45106   int arg2 ;
45107   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45108
45109   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45110   arg2 = (int)jarg2;
45111   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45112   if (!arg3) {
45113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45114     return ;
45115   }
45116   {
45117     try {
45118       try {
45119         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45120       }
45121       catch(std::out_of_range &_e) {
45122         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45123         return ;
45124       }
45125
45126     } catch (std::out_of_range& e) {
45127       {
45128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45129       };
45130     } catch (std::exception& e) {
45131       {
45132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45133       };
45134     } catch (...) {
45135       {
45136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45137       };
45138     }
45139   }
45140 }
45141
45142
45143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
45144   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45145   int arg2 ;
45146
45147   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45148   arg2 = (int)jarg2;
45149   {
45150     try {
45151       try {
45152         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45153       }
45154       catch(std::out_of_range &_e) {
45155         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45156         return ;
45157       }
45158
45159     } catch (std::out_of_range& e) {
45160       {
45161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45162       };
45163     } catch (std::exception& e) {
45164       {
45165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45166       };
45167     } catch (...) {
45168       {
45169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45170       };
45171     }
45172   }
45173 }
45174
45175
45176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45177   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45178   int arg2 ;
45179   int arg3 ;
45180
45181   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45182   arg2 = (int)jarg2;
45183   arg3 = (int)jarg3;
45184   {
45185     try {
45186       try {
45187         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45188       }
45189       catch(std::out_of_range &_e) {
45190         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45191         return ;
45192       }
45193       catch(std::invalid_argument &_e) {
45194         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45195         return ;
45196       }
45197
45198     } catch (std::out_of_range& e) {
45199       {
45200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45201       };
45202     } catch (std::exception& e) {
45203       {
45204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45205       };
45206     } catch (...) {
45207       {
45208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45209       };
45210     }
45211   }
45212 }
45213
45214
45215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45216   void * jresult ;
45217   Dali::TouchPoint *arg1 = 0 ;
45218   int arg2 ;
45219   std::vector< Dali::TouchPoint > *result = 0 ;
45220
45221   arg1 = (Dali::TouchPoint *)jarg1;
45222   if (!arg1) {
45223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45224     return 0;
45225   }
45226   arg2 = (int)jarg2;
45227   {
45228     try {
45229       try {
45230         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45231       }
45232       catch(std::out_of_range &_e) {
45233         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45234         return 0;
45235       }
45236
45237     } catch (std::out_of_range& e) {
45238       {
45239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45240       };
45241     } catch (std::exception& e) {
45242       {
45243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45244       };
45245     } catch (...) {
45246       {
45247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45248       };
45249     }
45250   }
45251   jresult = (void *)result;
45252   return jresult;
45253 }
45254
45255
45256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45257   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45258
45259   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45260   {
45261     try {
45262       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45263     } catch (std::out_of_range& e) {
45264       {
45265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45266       };
45267     } catch (std::exception& e) {
45268       {
45269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45270       };
45271     } catch (...) {
45272       {
45273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45274       };
45275     }
45276   }
45277 }
45278
45279
45280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45281   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45282   int arg2 ;
45283   int arg3 ;
45284
45285   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45286   arg2 = (int)jarg2;
45287   arg3 = (int)jarg3;
45288   {
45289     try {
45290       try {
45291         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45292       }
45293       catch(std::out_of_range &_e) {
45294         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45295         return ;
45296       }
45297       catch(std::invalid_argument &_e) {
45298         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45299         return ;
45300       }
45301
45302     } catch (std::out_of_range& e) {
45303       {
45304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45305       };
45306     } catch (std::exception& e) {
45307       {
45308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45309       };
45310     } catch (...) {
45311       {
45312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45313       };
45314     }
45315   }
45316 }
45317
45318
45319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45320   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45321   int arg2 ;
45322   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45323
45324   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45325   arg2 = (int)jarg2;
45326   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45327   if (!arg3) {
45328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45329     return ;
45330   }
45331   {
45332     try {
45333       try {
45334         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45335       }
45336       catch(std::out_of_range &_e) {
45337         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45338         return ;
45339       }
45340
45341     } catch (std::out_of_range& e) {
45342       {
45343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45344       };
45345     } catch (std::exception& e) {
45346       {
45347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45348       };
45349     } catch (...) {
45350       {
45351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45352       };
45353     }
45354   }
45355 }
45356
45357
45358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45359   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45360
45361   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45362   {
45363     try {
45364       delete arg1;
45365     } catch (std::out_of_range& e) {
45366       {
45367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45368       };
45369     } catch (std::exception& e) {
45370       {
45371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45372       };
45373     } catch (...) {
45374       {
45375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45376       };
45377     }
45378   }
45379 }
45380
45381
45382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45383   void * jresult ;
45384   Dali::Rect< int > *result = 0 ;
45385
45386   {
45387     try {
45388       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45389     } catch (std::out_of_range& e) {
45390       {
45391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45392       };
45393     } catch (std::exception& e) {
45394       {
45395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45396       };
45397     } catch (...) {
45398       {
45399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45400       };
45401     }
45402   }
45403   jresult = (void *)result;
45404   return jresult;
45405 }
45406
45407
45408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45409   void * jresult ;
45410   int arg1 ;
45411   int arg2 ;
45412   int arg3 ;
45413   int arg4 ;
45414   Dali::Rect< int > *result = 0 ;
45415
45416   arg1 = (int)jarg1;
45417   arg2 = (int)jarg2;
45418   arg3 = (int)jarg3;
45419   arg4 = (int)jarg4;
45420   {
45421     try {
45422       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45423     } catch (std::out_of_range& e) {
45424       {
45425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45426       };
45427     } catch (std::exception& e) {
45428       {
45429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45430       };
45431     } catch (...) {
45432       {
45433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45434       };
45435     }
45436   }
45437   jresult = (void *)result;
45438   return jresult;
45439 }
45440
45441
45442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45443   void * jresult ;
45444   Dali::Rect< int > *arg1 = 0 ;
45445   Dali::Rect< int > *result = 0 ;
45446
45447   arg1 = (Dali::Rect< int > *)jarg1;
45448   if (!arg1) {
45449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45450     return 0;
45451   }
45452   {
45453     try {
45454       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45455     } catch (std::out_of_range& e) {
45456       {
45457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45458       };
45459     } catch (std::exception& e) {
45460       {
45461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45462       };
45463     } catch (...) {
45464       {
45465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45466       };
45467     }
45468   }
45469   jresult = (void *)result;
45470   return jresult;
45471 }
45472
45473
45474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45475   void * jresult ;
45476   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45477   Dali::Rect< int > *arg2 = 0 ;
45478   Dali::Rect< int > *result = 0 ;
45479
45480   arg1 = (Dali::Rect< int > *)jarg1;
45481   arg2 = (Dali::Rect< int > *)jarg2;
45482   if (!arg2) {
45483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45484     return 0;
45485   }
45486   {
45487     try {
45488       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45489     } catch (std::out_of_range& e) {
45490       {
45491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45492       };
45493     } catch (std::exception& e) {
45494       {
45495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45496       };
45497     } catch (...) {
45498       {
45499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45500       };
45501     }
45502   }
45503   jresult = (void *)result;
45504   return jresult;
45505 }
45506
45507
45508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45509   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45510   int arg2 ;
45511   int arg3 ;
45512   int arg4 ;
45513   int arg5 ;
45514
45515   arg1 = (Dali::Rect< int > *)jarg1;
45516   arg2 = (int)jarg2;
45517   arg3 = (int)jarg3;
45518   arg4 = (int)jarg4;
45519   arg5 = (int)jarg5;
45520   {
45521     try {
45522       (arg1)->Set(arg2,arg3,arg4,arg5);
45523     } catch (std::out_of_range& e) {
45524       {
45525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45526       };
45527     } catch (std::exception& e) {
45528       {
45529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45530       };
45531     } catch (...) {
45532       {
45533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45534       };
45535     }
45536   }
45537 }
45538
45539
45540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45541   unsigned int jresult ;
45542   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45543   bool result;
45544
45545   arg1 = (Dali::Rect< int > *)jarg1;
45546   {
45547     try {
45548       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45549     } catch (std::out_of_range& e) {
45550       {
45551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45552       };
45553     } catch (std::exception& e) {
45554       {
45555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45556       };
45557     } catch (...) {
45558       {
45559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45560       };
45561     }
45562   }
45563   jresult = result;
45564   return jresult;
45565 }
45566
45567
45568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45569   int jresult ;
45570   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45571   int result;
45572
45573   arg1 = (Dali::Rect< int > *)jarg1;
45574   {
45575     try {
45576       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45577     } catch (std::out_of_range& e) {
45578       {
45579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45580       };
45581     } catch (std::exception& e) {
45582       {
45583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45584       };
45585     } catch (...) {
45586       {
45587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45588       };
45589     }
45590   }
45591   jresult = result;
45592   return jresult;
45593 }
45594
45595
45596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45597   int jresult ;
45598   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45599   int result;
45600
45601   arg1 = (Dali::Rect< int > *)jarg1;
45602   {
45603     try {
45604       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45605     } catch (std::out_of_range& e) {
45606       {
45607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45608       };
45609     } catch (std::exception& e) {
45610       {
45611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45612       };
45613     } catch (...) {
45614       {
45615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45616       };
45617     }
45618   }
45619   jresult = result;
45620   return jresult;
45621 }
45622
45623
45624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45625   int jresult ;
45626   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45627   int result;
45628
45629   arg1 = (Dali::Rect< int > *)jarg1;
45630   {
45631     try {
45632       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45633     } catch (std::out_of_range& e) {
45634       {
45635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45636       };
45637     } catch (std::exception& e) {
45638       {
45639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45640       };
45641     } catch (...) {
45642       {
45643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45644       };
45645     }
45646   }
45647   jresult = result;
45648   return jresult;
45649 }
45650
45651
45652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45653   int jresult ;
45654   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45655   int result;
45656
45657   arg1 = (Dali::Rect< int > *)jarg1;
45658   {
45659     try {
45660       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45661     } catch (std::out_of_range& e) {
45662       {
45663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45664       };
45665     } catch (std::exception& e) {
45666       {
45667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (...) {
45670       {
45671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45672       };
45673     }
45674   }
45675   jresult = result;
45676   return jresult;
45677 }
45678
45679
45680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45681   int jresult ;
45682   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45683   int result;
45684
45685   arg1 = (Dali::Rect< int > *)jarg1;
45686   {
45687     try {
45688       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45689     } catch (std::out_of_range& e) {
45690       {
45691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45692       };
45693     } catch (std::exception& e) {
45694       {
45695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45696       };
45697     } catch (...) {
45698       {
45699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45700       };
45701     }
45702   }
45703   jresult = result;
45704   return jresult;
45705 }
45706
45707
45708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45709   unsigned int jresult ;
45710   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45711   Dali::Rect< int > *arg2 = 0 ;
45712   bool result;
45713
45714   arg1 = (Dali::Rect< int > *)jarg1;
45715   arg2 = (Dali::Rect< int > *)jarg2;
45716   if (!arg2) {
45717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45718     return 0;
45719   }
45720   {
45721     try {
45722       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45723     } catch (std::out_of_range& e) {
45724       {
45725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45726       };
45727     } catch (std::exception& e) {
45728       {
45729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45730       };
45731     } catch (...) {
45732       {
45733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45734       };
45735     }
45736   }
45737   jresult = result;
45738   return jresult;
45739 }
45740
45741
45742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45743   unsigned int jresult ;
45744   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45745   Dali::Rect< int > *arg2 = 0 ;
45746   bool result;
45747
45748   arg1 = (Dali::Rect< int > *)jarg1;
45749   arg2 = (Dali::Rect< int > *)jarg2;
45750   if (!arg2) {
45751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45752     return 0;
45753   }
45754   {
45755     try {
45756       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45757     } catch (std::out_of_range& e) {
45758       {
45759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45760       };
45761     } catch (std::exception& e) {
45762       {
45763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45764       };
45765     } catch (...) {
45766       {
45767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45768       };
45769     }
45770   }
45771   jresult = result;
45772   return jresult;
45773 }
45774
45775
45776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45777   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45778   int arg2 ;
45779
45780   arg1 = (Dali::Rect< int > *)jarg1;
45781   arg2 = (int)jarg2;
45782   if (arg1) (arg1)->x = arg2;
45783 }
45784
45785
45786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45787   int jresult ;
45788   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45789   int result;
45790
45791   arg1 = (Dali::Rect< int > *)jarg1;
45792   result = (int) ((arg1)->x);
45793   jresult = result;
45794   return jresult;
45795 }
45796
45797
45798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45799   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45800   int arg2 ;
45801
45802   arg1 = (Dali::Rect< int > *)jarg1;
45803   arg2 = (int)jarg2;
45804   if (arg1) (arg1)->left = arg2;
45805 }
45806
45807
45808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
45809   int jresult ;
45810   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45811   int result;
45812
45813   arg1 = (Dali::Rect< int > *)jarg1;
45814   result = (int) ((arg1)->left);
45815   jresult = result;
45816   return jresult;
45817 }
45818
45819
45820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
45821   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45822   int arg2 ;
45823
45824   arg1 = (Dali::Rect< int > *)jarg1;
45825   arg2 = (int)jarg2;
45826   if (arg1) (arg1)->y = arg2;
45827 }
45828
45829
45830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
45831   int jresult ;
45832   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45833   int result;
45834
45835   arg1 = (Dali::Rect< int > *)jarg1;
45836   result = (int) ((arg1)->y);
45837   jresult = result;
45838   return jresult;
45839 }
45840
45841
45842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
45843   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45844   int arg2 ;
45845
45846   arg1 = (Dali::Rect< int > *)jarg1;
45847   arg2 = (int)jarg2;
45848   if (arg1) (arg1)->right = arg2;
45849 }
45850
45851
45852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
45853   int jresult ;
45854   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45855   int result;
45856
45857   arg1 = (Dali::Rect< int > *)jarg1;
45858   result = (int) ((arg1)->right);
45859   jresult = result;
45860   return jresult;
45861 }
45862
45863
45864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
45865   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45866   int arg2 ;
45867
45868   arg1 = (Dali::Rect< int > *)jarg1;
45869   arg2 = (int)jarg2;
45870   if (arg1) (arg1)->width = arg2;
45871 }
45872
45873
45874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
45875   int jresult ;
45876   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45877   int result;
45878
45879   arg1 = (Dali::Rect< int > *)jarg1;
45880   result = (int) ((arg1)->width);
45881   jresult = result;
45882   return jresult;
45883 }
45884
45885
45886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
45887   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45888   int arg2 ;
45889
45890   arg1 = (Dali::Rect< int > *)jarg1;
45891   arg2 = (int)jarg2;
45892   if (arg1) (arg1)->bottom = arg2;
45893 }
45894
45895
45896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
45897   int jresult ;
45898   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45899   int result;
45900
45901   arg1 = (Dali::Rect< int > *)jarg1;
45902   result = (int) ((arg1)->bottom);
45903   jresult = result;
45904   return jresult;
45905 }
45906
45907
45908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
45909   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45910   int arg2 ;
45911
45912   arg1 = (Dali::Rect< int > *)jarg1;
45913   arg2 = (int)jarg2;
45914   if (arg1) (arg1)->height = arg2;
45915 }
45916
45917
45918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
45919   int jresult ;
45920   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45921   int result;
45922
45923   arg1 = (Dali::Rect< int > *)jarg1;
45924   result = (int) ((arg1)->height);
45925   jresult = result;
45926   return jresult;
45927 }
45928
45929
45930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
45931   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45932   int arg2 ;
45933
45934   arg1 = (Dali::Rect< int > *)jarg1;
45935   arg2 = (int)jarg2;
45936   if (arg1) (arg1)->top = arg2;
45937 }
45938
45939
45940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
45941   int jresult ;
45942   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45943   int result;
45944
45945   arg1 = (Dali::Rect< int > *)jarg1;
45946   result = (int) ((arg1)->top);
45947   jresult = result;
45948   return jresult;
45949 }
45950
45951
45952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
45953   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45954
45955   arg1 = (Dali::Rect< int > *)jarg1;
45956   {
45957     try {
45958       delete arg1;
45959     } catch (std::out_of_range& e) {
45960       {
45961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45962       };
45963     } catch (std::exception& e) {
45964       {
45965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45966       };
45967     } catch (...) {
45968       {
45969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45970       };
45971     }
45972   }
45973 }
45974
45975
45976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
45977   void * jresult ;
45978   Dali::Rect< float > *result = 0 ;
45979
45980   {
45981     try {
45982       result = (Dali::Rect< float > *)new Dali::Rect< float >();
45983     } catch (std::out_of_range& e) {
45984       {
45985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45986       };
45987     } catch (std::exception& e) {
45988       {
45989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45990       };
45991     } catch (...) {
45992       {
45993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45994       };
45995     }
45996   }
45997   jresult = (void *)result;
45998   return jresult;
45999 }
46000
46001
46002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46003   void * jresult ;
46004   float arg1 ;
46005   float arg2 ;
46006   float arg3 ;
46007   float arg4 ;
46008   Dali::Rect< float > *result = 0 ;
46009
46010   arg1 = (float)jarg1;
46011   arg2 = (float)jarg2;
46012   arg3 = (float)jarg3;
46013   arg4 = (float)jarg4;
46014   {
46015     try {
46016       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46017     } catch (std::out_of_range& e) {
46018       {
46019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46020       };
46021     } catch (std::exception& e) {
46022       {
46023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46024       };
46025     } catch (...) {
46026       {
46027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46028       };
46029     }
46030   }
46031   jresult = (void *)result;
46032   return jresult;
46033 }
46034
46035
46036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46037   void * jresult ;
46038   Dali::Rect< float > *arg1 = 0 ;
46039   Dali::Rect< float > *result = 0 ;
46040
46041   arg1 = (Dali::Rect< float > *)jarg1;
46042   if (!arg1) {
46043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46044     return 0;
46045   }
46046   {
46047     try {
46048       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46049     } catch (std::out_of_range& e) {
46050       {
46051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46052       };
46053     } catch (std::exception& e) {
46054       {
46055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46056       };
46057     } catch (...) {
46058       {
46059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46060       };
46061     }
46062   }
46063   jresult = (void *)result;
46064   return jresult;
46065 }
46066
46067
46068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46069   void * jresult ;
46070   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46071   Dali::Rect< float > *arg2 = 0 ;
46072   Dali::Rect< float > *result = 0 ;
46073
46074   arg1 = (Dali::Rect< float > *)jarg1;
46075   arg2 = (Dali::Rect< float > *)jarg2;
46076   if (!arg2) {
46077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46078     return 0;
46079   }
46080   {
46081     try {
46082       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46083     } catch (std::out_of_range& e) {
46084       {
46085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46086       };
46087     } catch (std::exception& e) {
46088       {
46089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46090       };
46091     } catch (...) {
46092       {
46093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46094       };
46095     }
46096   }
46097   jresult = (void *)result;
46098   return jresult;
46099 }
46100
46101
46102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46103   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46104   float arg2 ;
46105   float arg3 ;
46106   float arg4 ;
46107   float arg5 ;
46108
46109   arg1 = (Dali::Rect< float > *)jarg1;
46110   arg2 = (float)jarg2;
46111   arg3 = (float)jarg3;
46112   arg4 = (float)jarg4;
46113   arg5 = (float)jarg5;
46114   {
46115     try {
46116       (arg1)->Set(arg2,arg3,arg4,arg5);
46117     } catch (std::out_of_range& e) {
46118       {
46119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46120       };
46121     } catch (std::exception& e) {
46122       {
46123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46124       };
46125     } catch (...) {
46126       {
46127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46128       };
46129     }
46130   }
46131 }
46132
46133
46134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46135   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46136   float arg2 ;
46137
46138   arg1 = (Dali::Rect< float > *)jarg1;
46139   arg2 = (float)jarg2;
46140   if (arg1) (arg1)->x = arg2;
46141 }
46142
46143
46144 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46145   float jresult ;
46146   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46147   float result;
46148
46149   arg1 = (Dali::Rect< float > *)jarg1;
46150   result = (float) ((arg1)->x);
46151   jresult = result;
46152   return jresult;
46153 }
46154
46155
46156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46157   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46158   float arg2 ;
46159
46160   arg1 = (Dali::Rect< float > *)jarg1;
46161   arg2 = (float)jarg2;
46162   if (arg1) (arg1)->left = arg2;
46163 }
46164
46165
46166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46167   float jresult ;
46168   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46169   float result;
46170
46171   arg1 = (Dali::Rect< float > *)jarg1;
46172   result = (float) ((arg1)->left);
46173   jresult = result;
46174   return jresult;
46175 }
46176
46177
46178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46179   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46180   float arg2 ;
46181
46182   arg1 = (Dali::Rect< float > *)jarg1;
46183   arg2 = (float)jarg2;
46184   if (arg1) (arg1)->y = arg2;
46185 }
46186
46187
46188 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46189   float jresult ;
46190   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46191   float result;
46192
46193   arg1 = (Dali::Rect< float > *)jarg1;
46194   result = (float) ((arg1)->y);
46195   jresult = result;
46196   return jresult;
46197 }
46198
46199
46200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46201   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46202   float arg2 ;
46203
46204   arg1 = (Dali::Rect< float > *)jarg1;
46205   arg2 = (float)jarg2;
46206   if (arg1) (arg1)->right = arg2;
46207 }
46208
46209
46210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46211   float jresult ;
46212   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46213   float result;
46214
46215   arg1 = (Dali::Rect< float > *)jarg1;
46216   result = (float) ((arg1)->right);
46217   jresult = result;
46218   return jresult;
46219 }
46220
46221
46222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46223   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46224   float arg2 ;
46225
46226   arg1 = (Dali::Rect< float > *)jarg1;
46227   arg2 = (float)jarg2;
46228   if (arg1) (arg1)->width = arg2;
46229 }
46230
46231
46232 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46233   float jresult ;
46234   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46235   float result;
46236
46237   arg1 = (Dali::Rect< float > *)jarg1;
46238   result = (float) ((arg1)->width);
46239   jresult = result;
46240   return jresult;
46241 }
46242
46243
46244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46245   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46246   float arg2 ;
46247
46248   arg1 = (Dali::Rect< float > *)jarg1;
46249   arg2 = (float)jarg2;
46250   if (arg1) (arg1)->bottom = arg2;
46251 }
46252
46253
46254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46255   float jresult ;
46256   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46257   float result;
46258
46259   arg1 = (Dali::Rect< float > *)jarg1;
46260   result = (float) ((arg1)->bottom);
46261   jresult = result;
46262   return jresult;
46263 }
46264
46265
46266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46267   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46268   float arg2 ;
46269
46270   arg1 = (Dali::Rect< float > *)jarg1;
46271   arg2 = (float)jarg2;
46272   if (arg1) (arg1)->height = arg2;
46273 }
46274
46275
46276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46277   float jresult ;
46278   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46279   float result;
46280
46281   arg1 = (Dali::Rect< float > *)jarg1;
46282   result = (float) ((arg1)->height);
46283   jresult = result;
46284   return jresult;
46285 }
46286
46287
46288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46289   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46290   float arg2 ;
46291
46292   arg1 = (Dali::Rect< float > *)jarg1;
46293   arg2 = (float)jarg2;
46294   if (arg1) (arg1)->top = arg2;
46295 }
46296
46297
46298 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46299   float jresult ;
46300   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46301   float result;
46302
46303   arg1 = (Dali::Rect< float > *)jarg1;
46304   result = (float) ((arg1)->top);
46305   jresult = result;
46306   return jresult;
46307 }
46308
46309
46310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46311   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46312
46313   arg1 = (Dali::Rect< float > *)jarg1;
46314   {
46315     try {
46316       delete arg1;
46317     } catch (std::out_of_range& e) {
46318       {
46319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46320       };
46321     } catch (std::exception& e) {
46322       {
46323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46324       };
46325     } catch (...) {
46326       {
46327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46328       };
46329     }
46330   }
46331 }
46332
46333
46334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46335   int jresult ;
46336   int result;
46337
46338   result = (int)Dali::Vector< int >::BaseType;
46339   jresult = (int)result;
46340   return jresult;
46341 }
46342
46343
46344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46345   void * jresult ;
46346   Dali::Vector< int > *result = 0 ;
46347
46348   {
46349     try {
46350       result = (Dali::Vector< int > *)new Dali::Vector< int >();
46351     } catch (std::out_of_range& e) {
46352       {
46353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46354       };
46355     } catch (std::exception& e) {
46356       {
46357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46358       };
46359     } catch (...) {
46360       {
46361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46362       };
46363     }
46364   }
46365   jresult = (void *)result;
46366   return jresult;
46367 }
46368
46369
46370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
46371   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46372
46373   arg1 = (Dali::Vector< int > *)jarg1;
46374   {
46375     try {
46376       delete arg1;
46377     } catch (std::out_of_range& e) {
46378       {
46379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46380       };
46381     } catch (std::exception& e) {
46382       {
46383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46384       };
46385     } catch (...) {
46386       {
46387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46388       };
46389     }
46390   }
46391 }
46392
46393
46394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46395   void * jresult ;
46396   Dali::Vector< int > *arg1 = 0 ;
46397   Dali::Vector< int > *result = 0 ;
46398
46399   arg1 = (Dali::Vector< int > *)jarg1;
46400   if (!arg1) {
46401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46402     return 0;
46403   }
46404   {
46405     try {
46406       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46407     } catch (std::out_of_range& e) {
46408       {
46409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46410       };
46411     } catch (std::exception& e) {
46412       {
46413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46414       };
46415     } catch (...) {
46416       {
46417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46418       };
46419     }
46420   }
46421   jresult = (void *)result;
46422   return jresult;
46423 }
46424
46425
46426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46427   void * jresult ;
46428   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46429   Dali::Vector< int > *arg2 = 0 ;
46430   Dali::Vector< int > *result = 0 ;
46431
46432   arg1 = (Dali::Vector< int > *)jarg1;
46433   arg2 = (Dali::Vector< int > *)jarg2;
46434   if (!arg2) {
46435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46436     return 0;
46437   }
46438   {
46439     try {
46440       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46441     } catch (std::out_of_range& e) {
46442       {
46443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46444       };
46445     } catch (std::exception& e) {
46446       {
46447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46448       };
46449     } catch (...) {
46450       {
46451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46452       };
46453     }
46454   }
46455   jresult = (void *)result;
46456   return jresult;
46457 }
46458
46459
46460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46461   void * jresult ;
46462   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46463   Dali::Vector< int >::Iterator result;
46464
46465   arg1 = (Dali::Vector< int > *)jarg1;
46466   {
46467     try {
46468       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46469     } catch (std::out_of_range& e) {
46470       {
46471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46472       };
46473     } catch (std::exception& e) {
46474       {
46475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46476       };
46477     } catch (...) {
46478       {
46479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46480       };
46481     }
46482   }
46483   jresult = (void *)result;
46484   return jresult;
46485 }
46486
46487
46488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46489   void * jresult ;
46490   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46491   Dali::Vector< int >::Iterator result;
46492
46493   arg1 = (Dali::Vector< int > *)jarg1;
46494   {
46495     try {
46496       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46497     } catch (std::out_of_range& e) {
46498       {
46499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46500       };
46501     } catch (std::exception& e) {
46502       {
46503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46504       };
46505     } catch (...) {
46506       {
46507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46508       };
46509     }
46510   }
46511   jresult = (void *)result;
46512   return jresult;
46513 }
46514
46515
46516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46517   void * jresult ;
46518   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46519   Dali::Vector< int >::SizeType arg2 ;
46520   Dali::Vector< int >::ItemType *result = 0 ;
46521
46522   arg1 = (Dali::Vector< int > *)jarg1;
46523   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46524   {
46525     try {
46526       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46527     } catch (std::out_of_range& e) {
46528       {
46529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46530       };
46531     } catch (std::exception& e) {
46532       {
46533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46534       };
46535     } catch (...) {
46536       {
46537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46538       };
46539     }
46540   }
46541   jresult = (void *)result;
46542   return jresult;
46543 }
46544
46545
46546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46547   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46548   Dali::Vector< int >::ItemType *arg2 = 0 ;
46549   Dali::Vector< int >::ItemType temp2 ;
46550
46551   arg1 = (Dali::Vector< int > *)jarg1;
46552   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46553   arg2 = &temp2;
46554   {
46555     try {
46556       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46557     } catch (std::out_of_range& e) {
46558       {
46559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46560       };
46561     } catch (std::exception& e) {
46562       {
46563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46564       };
46565     } catch (...) {
46566       {
46567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46568       };
46569     }
46570   }
46571 }
46572
46573
46574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46575   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46576   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46577   Dali::Vector< int >::ItemType *arg3 = 0 ;
46578   Dali::Vector< int >::ItemType temp3 ;
46579
46580   arg1 = (Dali::Vector< int > *)jarg1;
46581   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46582   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46583   arg3 = &temp3;
46584   {
46585     try {
46586       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46587     } catch (std::out_of_range& e) {
46588       {
46589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46590       };
46591     } catch (std::exception& e) {
46592       {
46593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46594       };
46595     } catch (...) {
46596       {
46597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46598       };
46599     }
46600   }
46601 }
46602
46603
46604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46605   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46606   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46607   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46608   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46609
46610   arg1 = (Dali::Vector< int > *)jarg1;
46611   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46612   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46613   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46614   {
46615     try {
46616       (arg1)->Insert(arg2,arg3,arg4);
46617     } catch (std::out_of_range& e) {
46618       {
46619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46620       };
46621     } catch (std::exception& e) {
46622       {
46623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46624       };
46625     } catch (...) {
46626       {
46627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46628       };
46629     }
46630   }
46631 }
46632
46633
46634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46635   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46636   Dali::Vector< int >::SizeType arg2 ;
46637
46638   arg1 = (Dali::Vector< int > *)jarg1;
46639   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46640   {
46641     try {
46642       (arg1)->Reserve(arg2);
46643     } catch (std::out_of_range& e) {
46644       {
46645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46646       };
46647     } catch (std::exception& e) {
46648       {
46649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46650       };
46651     } catch (...) {
46652       {
46653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46654       };
46655     }
46656   }
46657 }
46658
46659
46660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46661   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46662   Dali::Vector< int >::SizeType arg2 ;
46663
46664   arg1 = (Dali::Vector< int > *)jarg1;
46665   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46666   {
46667     try {
46668       (arg1)->Resize(arg2);
46669     } catch (std::out_of_range& e) {
46670       {
46671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46672       };
46673     } catch (std::exception& e) {
46674       {
46675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46676       };
46677     } catch (...) {
46678       {
46679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46680       };
46681     }
46682   }
46683 }
46684
46685
46686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46687   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46688   Dali::Vector< int >::SizeType arg2 ;
46689   Dali::Vector< int >::ItemType *arg3 = 0 ;
46690   Dali::Vector< int >::ItemType temp3 ;
46691
46692   arg1 = (Dali::Vector< int > *)jarg1;
46693   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46694   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46695   arg3 = &temp3;
46696   {
46697     try {
46698       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46699     } catch (std::out_of_range& e) {
46700       {
46701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46702       };
46703     } catch (std::exception& e) {
46704       {
46705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46706       };
46707     } catch (...) {
46708       {
46709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46710       };
46711     }
46712   }
46713 }
46714
46715
46716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46717   void * jresult ;
46718   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46719   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46720   Dali::Vector< int >::Iterator result;
46721
46722   arg1 = (Dali::Vector< int > *)jarg1;
46723   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46724   {
46725     try {
46726       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46727     } catch (std::out_of_range& e) {
46728       {
46729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46730       };
46731     } catch (std::exception& e) {
46732       {
46733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46734       };
46735     } catch (...) {
46736       {
46737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46738       };
46739     }
46740   }
46741   jresult = (void *)result;
46742   return jresult;
46743 }
46744
46745
46746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46747   void * jresult ;
46748   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46749   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46750   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46751   Dali::Vector< int >::Iterator result;
46752
46753   arg1 = (Dali::Vector< int > *)jarg1;
46754   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46755   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46756   {
46757     try {
46758       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46759     } catch (std::out_of_range& e) {
46760       {
46761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46762       };
46763     } catch (std::exception& e) {
46764       {
46765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46766       };
46767     } catch (...) {
46768       {
46769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46770       };
46771     }
46772   }
46773   jresult = (void *)result;
46774   return jresult;
46775 }
46776
46777
46778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46779   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46780   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46781
46782   arg1 = (Dali::Vector< int > *)jarg1;
46783   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46784   {
46785     try {
46786       (arg1)->Remove(arg2);
46787     } catch (std::out_of_range& e) {
46788       {
46789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46790       };
46791     } catch (std::exception& e) {
46792       {
46793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46794       };
46795     } catch (...) {
46796       {
46797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46798       };
46799     }
46800   }
46801 }
46802
46803
46804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
46805   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46806   Dali::Vector< int > *arg2 = 0 ;
46807
46808   arg1 = (Dali::Vector< int > *)jarg1;
46809   arg2 = (Dali::Vector< int > *)jarg2;
46810   if (!arg2) {
46811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
46812     return ;
46813   }
46814   {
46815     try {
46816       (arg1)->Swap(*arg2);
46817     } catch (std::out_of_range& e) {
46818       {
46819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46820       };
46821     } catch (std::exception& e) {
46822       {
46823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46824       };
46825     } catch (...) {
46826       {
46827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46828       };
46829     }
46830   }
46831 }
46832
46833
46834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
46835   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46836
46837   arg1 = (Dali::Vector< int > *)jarg1;
46838   {
46839     try {
46840       (arg1)->Clear();
46841     } catch (std::out_of_range& e) {
46842       {
46843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46844       };
46845     } catch (std::exception& e) {
46846       {
46847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46848       };
46849     } catch (...) {
46850       {
46851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46852       };
46853     }
46854   }
46855 }
46856
46857
46858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
46859   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46860
46861   arg1 = (Dali::Vector< int > *)jarg1;
46862   {
46863     try {
46864       (arg1)->Release();
46865     } catch (std::out_of_range& e) {
46866       {
46867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46868       };
46869     } catch (std::exception& e) {
46870       {
46871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46872       };
46873     } catch (...) {
46874       {
46875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46876       };
46877     }
46878   }
46879 }
46880
46881
46882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
46883   int jresult ;
46884   int result;
46885
46886   result = (int)Dali::Vector< float >::BaseType;
46887   jresult = (int)result;
46888   return jresult;
46889 }
46890
46891
46892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
46893   void * jresult ;
46894   Dali::Vector< float > *result = 0 ;
46895
46896   {
46897     try {
46898       result = (Dali::Vector< float > *)new Dali::Vector< float >();
46899     } catch (std::out_of_range& e) {
46900       {
46901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46902       };
46903     } catch (std::exception& e) {
46904       {
46905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46906       };
46907     } catch (...) {
46908       {
46909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46910       };
46911     }
46912   }
46913   jresult = (void *)result;
46914   return jresult;
46915 }
46916
46917
46918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
46919   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46920
46921   arg1 = (Dali::Vector< float > *)jarg1;
46922   {
46923     try {
46924       delete arg1;
46925     } catch (std::out_of_range& e) {
46926       {
46927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46928       };
46929     } catch (std::exception& e) {
46930       {
46931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46932       };
46933     } catch (...) {
46934       {
46935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46936       };
46937     }
46938   }
46939 }
46940
46941
46942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
46943   void * jresult ;
46944   Dali::Vector< float > *arg1 = 0 ;
46945   Dali::Vector< float > *result = 0 ;
46946
46947   arg1 = (Dali::Vector< float > *)jarg1;
46948   if (!arg1) {
46949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46950     return 0;
46951   }
46952   {
46953     try {
46954       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
46955     } catch (std::out_of_range& e) {
46956       {
46957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46958       };
46959     } catch (std::exception& e) {
46960       {
46961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46962       };
46963     } catch (...) {
46964       {
46965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46966       };
46967     }
46968   }
46969   jresult = (void *)result;
46970   return jresult;
46971 }
46972
46973
46974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
46975   void * jresult ;
46976   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
46977   Dali::Vector< float > *arg2 = 0 ;
46978   Dali::Vector< float > *result = 0 ;
46979
46980   arg1 = (Dali::Vector< float > *)jarg1;
46981   arg2 = (Dali::Vector< float > *)jarg2;
46982   if (!arg2) {
46983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
46984     return 0;
46985   }
46986   {
46987     try {
46988       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
46989     } catch (std::out_of_range& e) {
46990       {
46991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46992       };
46993     } catch (std::exception& e) {
46994       {
46995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46996       };
46997     } catch (...) {
46998       {
46999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47000       };
47001     }
47002   }
47003   jresult = (void *)result;
47004   return jresult;
47005 }
47006
47007
47008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47009   void * jresult ;
47010   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47011   Dali::Vector< float >::Iterator result;
47012
47013   arg1 = (Dali::Vector< float > *)jarg1;
47014   {
47015     try {
47016       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47017     } catch (std::out_of_range& e) {
47018       {
47019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47020       };
47021     } catch (std::exception& e) {
47022       {
47023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47024       };
47025     } catch (...) {
47026       {
47027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47028       };
47029     }
47030   }
47031   jresult = (void *)result;
47032   return jresult;
47033 }
47034
47035
47036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47037   void * jresult ;
47038   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47039   Dali::Vector< float >::Iterator result;
47040
47041   arg1 = (Dali::Vector< float > *)jarg1;
47042   {
47043     try {
47044       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47045     } catch (std::out_of_range& e) {
47046       {
47047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47048       };
47049     } catch (std::exception& e) {
47050       {
47051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47052       };
47053     } catch (...) {
47054       {
47055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47056       };
47057     }
47058   }
47059   jresult = (void *)result;
47060   return jresult;
47061 }
47062
47063
47064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47065   void * jresult ;
47066   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47067   Dali::Vector< float >::SizeType arg2 ;
47068   Dali::Vector< float >::ItemType *result = 0 ;
47069
47070   arg1 = (Dali::Vector< float > *)jarg1;
47071   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47072   {
47073     try {
47074       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47075     } catch (std::out_of_range& e) {
47076       {
47077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47078       };
47079     } catch (std::exception& e) {
47080       {
47081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47082       };
47083     } catch (...) {
47084       {
47085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47086       };
47087     }
47088   }
47089   jresult = (void *)result;
47090   return jresult;
47091 }
47092
47093
47094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47095   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47096   Dali::Vector< float >::ItemType *arg2 = 0 ;
47097   Dali::Vector< float >::ItemType temp2 ;
47098
47099   arg1 = (Dali::Vector< float > *)jarg1;
47100   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47101   arg2 = &temp2;
47102   {
47103     try {
47104       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47105     } catch (std::out_of_range& e) {
47106       {
47107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47108       };
47109     } catch (std::exception& e) {
47110       {
47111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47112       };
47113     } catch (...) {
47114       {
47115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47116       };
47117     }
47118   }
47119 }
47120
47121
47122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47123   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47124   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47125   Dali::Vector< float >::ItemType *arg3 = 0 ;
47126   Dali::Vector< float >::ItemType temp3 ;
47127
47128   arg1 = (Dali::Vector< float > *)jarg1;
47129   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47130   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47131   arg3 = &temp3;
47132   {
47133     try {
47134       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47135     } catch (std::out_of_range& e) {
47136       {
47137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47138       };
47139     } catch (std::exception& e) {
47140       {
47141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47142       };
47143     } catch (...) {
47144       {
47145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47146       };
47147     }
47148   }
47149 }
47150
47151
47152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47153   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47154   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47155   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47156   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47157
47158   arg1 = (Dali::Vector< float > *)jarg1;
47159   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47160   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47161   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47162   {
47163     try {
47164       (arg1)->Insert(arg2,arg3,arg4);
47165     } catch (std::out_of_range& e) {
47166       {
47167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47168       };
47169     } catch (std::exception& e) {
47170       {
47171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47172       };
47173     } catch (...) {
47174       {
47175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47176       };
47177     }
47178   }
47179 }
47180
47181
47182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47183   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47184   Dali::Vector< float >::SizeType arg2 ;
47185
47186   arg1 = (Dali::Vector< float > *)jarg1;
47187   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47188   {
47189     try {
47190       (arg1)->Reserve(arg2);
47191     } catch (std::out_of_range& e) {
47192       {
47193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47194       };
47195     } catch (std::exception& e) {
47196       {
47197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47198       };
47199     } catch (...) {
47200       {
47201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47202       };
47203     }
47204   }
47205 }
47206
47207
47208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47209   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47210   Dali::Vector< float >::SizeType arg2 ;
47211
47212   arg1 = (Dali::Vector< float > *)jarg1;
47213   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47214   {
47215     try {
47216       (arg1)->Resize(arg2);
47217     } catch (std::out_of_range& e) {
47218       {
47219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47220       };
47221     } catch (std::exception& e) {
47222       {
47223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47224       };
47225     } catch (...) {
47226       {
47227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47228       };
47229     }
47230   }
47231 }
47232
47233
47234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47235   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47236   Dali::Vector< float >::SizeType arg2 ;
47237   Dali::Vector< float >::ItemType *arg3 = 0 ;
47238   Dali::Vector< float >::ItemType temp3 ;
47239
47240   arg1 = (Dali::Vector< float > *)jarg1;
47241   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47242   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47243   arg3 = &temp3;
47244   {
47245     try {
47246       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47247     } catch (std::out_of_range& e) {
47248       {
47249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47250       };
47251     } catch (std::exception& e) {
47252       {
47253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47254       };
47255     } catch (...) {
47256       {
47257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47258       };
47259     }
47260   }
47261 }
47262
47263
47264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47265   void * jresult ;
47266   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47267   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47268   Dali::Vector< float >::Iterator result;
47269
47270   arg1 = (Dali::Vector< float > *)jarg1;
47271   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47272   {
47273     try {
47274       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47275     } catch (std::out_of_range& e) {
47276       {
47277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47278       };
47279     } catch (std::exception& e) {
47280       {
47281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47282       };
47283     } catch (...) {
47284       {
47285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47286       };
47287     }
47288   }
47289   jresult = (void *)result;
47290   return jresult;
47291 }
47292
47293
47294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47295   void * jresult ;
47296   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47297   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47298   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47299   Dali::Vector< float >::Iterator result;
47300
47301   arg1 = (Dali::Vector< float > *)jarg1;
47302   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47303   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47304   {
47305     try {
47306       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47307     } catch (std::out_of_range& e) {
47308       {
47309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47310       };
47311     } catch (std::exception& e) {
47312       {
47313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47314       };
47315     } catch (...) {
47316       {
47317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47318       };
47319     }
47320   }
47321   jresult = (void *)result;
47322   return jresult;
47323 }
47324
47325
47326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47327   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47328   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47329
47330   arg1 = (Dali::Vector< float > *)jarg1;
47331   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47332   {
47333     try {
47334       (arg1)->Remove(arg2);
47335     } catch (std::out_of_range& e) {
47336       {
47337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47338       };
47339     } catch (std::exception& e) {
47340       {
47341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47342       };
47343     } catch (...) {
47344       {
47345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47346       };
47347     }
47348   }
47349 }
47350
47351
47352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47353   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47354   Dali::Vector< float > *arg2 = 0 ;
47355
47356   arg1 = (Dali::Vector< float > *)jarg1;
47357   arg2 = (Dali::Vector< float > *)jarg2;
47358   if (!arg2) {
47359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47360     return ;
47361   }
47362   {
47363     try {
47364       (arg1)->Swap(*arg2);
47365     } catch (std::out_of_range& e) {
47366       {
47367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47368       };
47369     } catch (std::exception& e) {
47370       {
47371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47372       };
47373     } catch (...) {
47374       {
47375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47376       };
47377     }
47378   }
47379 }
47380
47381
47382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47383   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47384
47385   arg1 = (Dali::Vector< float > *)jarg1;
47386   {
47387     try {
47388       (arg1)->Clear();
47389     } catch (std::out_of_range& e) {
47390       {
47391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47392       };
47393     } catch (std::exception& e) {
47394       {
47395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47396       };
47397     } catch (...) {
47398       {
47399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47400       };
47401     }
47402   }
47403 }
47404
47405
47406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47407   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47408
47409   arg1 = (Dali::Vector< float > *)jarg1;
47410   {
47411     try {
47412       (arg1)->Release();
47413     } catch (std::out_of_range& e) {
47414       {
47415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47416       };
47417     } catch (std::exception& e) {
47418       {
47419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47420       };
47421     } catch (...) {
47422       {
47423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47424       };
47425     }
47426   }
47427 }
47428
47429
47430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47431   int jresult ;
47432   int result;
47433
47434   result = (int)Dali::Vector< unsigned char >::BaseType;
47435   jresult = (int)result;
47436   return jresult;
47437 }
47438
47439
47440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47441   void * jresult ;
47442   Dali::Vector< unsigned char > *result = 0 ;
47443
47444   {
47445     try {
47446       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
47447     } catch (std::out_of_range& e) {
47448       {
47449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47450       };
47451     } catch (std::exception& e) {
47452       {
47453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47454       };
47455     } catch (...) {
47456       {
47457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47458       };
47459     }
47460   }
47461   jresult = (void *)result;
47462   return jresult;
47463 }
47464
47465
47466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
47467   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47468
47469   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47470   {
47471     try {
47472       delete arg1;
47473     } catch (std::out_of_range& e) {
47474       {
47475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47476       };
47477     } catch (std::exception& e) {
47478       {
47479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47480       };
47481     } catch (...) {
47482       {
47483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47484       };
47485     }
47486   }
47487 }
47488
47489
47490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47491   void * jresult ;
47492   Dali::Vector< unsigned char > *arg1 = 0 ;
47493   Dali::Vector< unsigned char > *result = 0 ;
47494
47495   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47496   if (!arg1) {
47497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47498     return 0;
47499   }
47500   {
47501     try {
47502       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47503     } catch (std::out_of_range& e) {
47504       {
47505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47506       };
47507     } catch (std::exception& e) {
47508       {
47509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47510       };
47511     } catch (...) {
47512       {
47513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47514       };
47515     }
47516   }
47517   jresult = (void *)result;
47518   return jresult;
47519 }
47520
47521
47522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47523   void * jresult ;
47524   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47525   Dali::Vector< unsigned char > *arg2 = 0 ;
47526   Dali::Vector< unsigned char > *result = 0 ;
47527
47528   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47529   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47530   if (!arg2) {
47531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47532     return 0;
47533   }
47534   {
47535     try {
47536       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47537     } catch (std::out_of_range& e) {
47538       {
47539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47540       };
47541     } catch (std::exception& e) {
47542       {
47543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47544       };
47545     } catch (...) {
47546       {
47547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47548       };
47549     }
47550   }
47551   jresult = (void *)result;
47552   return jresult;
47553 }
47554
47555
47556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47557   void * jresult ;
47558   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47559   Dali::Vector< unsigned char >::Iterator result;
47560
47561   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47562   {
47563     try {
47564       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47565     } catch (std::out_of_range& e) {
47566       {
47567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47568       };
47569     } catch (std::exception& e) {
47570       {
47571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47572       };
47573     } catch (...) {
47574       {
47575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47576       };
47577     }
47578   }
47579   jresult = (void *)result;
47580   return jresult;
47581 }
47582
47583
47584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47585   void * jresult ;
47586   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47587   Dali::Vector< unsigned char >::Iterator result;
47588
47589   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47590   {
47591     try {
47592       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47593     } catch (std::out_of_range& e) {
47594       {
47595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47596       };
47597     } catch (std::exception& e) {
47598       {
47599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47600       };
47601     } catch (...) {
47602       {
47603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47604       };
47605     }
47606   }
47607   jresult = (void *)result;
47608   return jresult;
47609 }
47610
47611
47612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47613   void * jresult ;
47614   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47615   Dali::Vector< unsigned char >::SizeType arg2 ;
47616   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47617
47618   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47619   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47620   {
47621     try {
47622       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47623     } catch (std::out_of_range& e) {
47624       {
47625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47626       };
47627     } catch (std::exception& e) {
47628       {
47629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47630       };
47631     } catch (...) {
47632       {
47633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47634       };
47635     }
47636   }
47637   jresult = (void *)result;
47638   return jresult;
47639 }
47640
47641
47642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47643   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47644   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47645   Dali::Vector< unsigned char >::ItemType temp2 ;
47646
47647   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47648   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47649   arg2 = &temp2;
47650   {
47651     try {
47652       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47653     } catch (std::out_of_range& e) {
47654       {
47655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47656       };
47657     } catch (std::exception& e) {
47658       {
47659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47660       };
47661     } catch (...) {
47662       {
47663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47664       };
47665     }
47666   }
47667 }
47668
47669
47670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47671   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47672   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47673   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47674   Dali::Vector< unsigned char >::ItemType temp3 ;
47675
47676   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47677   arg2 = jarg2;
47678   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47679   arg3 = &temp3;
47680   {
47681     try {
47682       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47683     } catch (std::out_of_range& e) {
47684       {
47685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47686       };
47687     } catch (std::exception& e) {
47688       {
47689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47690       };
47691     } catch (...) {
47692       {
47693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47694       };
47695     }
47696   }
47697
47698
47699 }
47700
47701
47702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47703   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47704   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47705   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47706   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47707
47708   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47709   arg2 = jarg2;
47710   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47711   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47712   {
47713     try {
47714       (arg1)->Insert(arg2,arg3,arg4);
47715     } catch (std::out_of_range& e) {
47716       {
47717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47718       };
47719     } catch (std::exception& e) {
47720       {
47721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47722       };
47723     } catch (...) {
47724       {
47725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47726       };
47727     }
47728   }
47729
47730
47731 }
47732
47733
47734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
47735   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47736   Dali::Vector< unsigned char >::SizeType arg2 ;
47737
47738   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47739   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47740   {
47741     try {
47742       (arg1)->Reserve(arg2);
47743     } catch (std::out_of_range& e) {
47744       {
47745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47746       };
47747     } catch (std::exception& e) {
47748       {
47749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47750       };
47751     } catch (...) {
47752       {
47753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47754       };
47755     }
47756   }
47757 }
47758
47759
47760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47761   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47762   Dali::Vector< unsigned char >::SizeType arg2 ;
47763
47764   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47765   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47766   {
47767     try {
47768       (arg1)->Resize(arg2);
47769     } catch (std::out_of_range& e) {
47770       {
47771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47772       };
47773     } catch (std::exception& e) {
47774       {
47775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47776       };
47777     } catch (...) {
47778       {
47779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47780       };
47781     }
47782   }
47783 }
47784
47785
47786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47787   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47788   Dali::Vector< unsigned char >::SizeType arg2 ;
47789   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47790   Dali::Vector< unsigned char >::ItemType temp3 ;
47791
47792   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47793   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47794   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47795   arg3 = &temp3;
47796   {
47797     try {
47798       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47799     } catch (std::out_of_range& e) {
47800       {
47801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47802       };
47803     } catch (std::exception& e) {
47804       {
47805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47806       };
47807     } catch (...) {
47808       {
47809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47810       };
47811     }
47812   }
47813 }
47814
47815
47816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
47817   void * jresult ;
47818   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47819   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47820   Dali::Vector< unsigned char >::Iterator result;
47821
47822   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47823   arg2 = jarg2;
47824   {
47825     try {
47826       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
47827     } catch (std::out_of_range& e) {
47828       {
47829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47830       };
47831     } catch (std::exception& e) {
47832       {
47833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47834       };
47835     } catch (...) {
47836       {
47837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47838       };
47839     }
47840   }
47841   jresult = (void *)result;
47842
47843
47844   return jresult;
47845 }
47846
47847
47848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
47849   void * jresult ;
47850   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47851   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47852   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47853   Dali::Vector< unsigned char >::Iterator result;
47854
47855   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47856   arg2 = jarg2;
47857   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47858   {
47859     try {
47860       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
47861     } catch (std::out_of_range& e) {
47862       {
47863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47864       };
47865     } catch (std::exception& e) {
47866       {
47867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47868       };
47869     } catch (...) {
47870       {
47871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47872       };
47873     }
47874   }
47875   jresult = (void *)result;
47876
47877
47878   return jresult;
47879 }
47880
47881
47882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
47883   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47884   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47885
47886   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47887   arg2 = jarg2;
47888   {
47889     try {
47890       (arg1)->Remove(arg2);
47891     } catch (std::out_of_range& e) {
47892       {
47893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47894       };
47895     } catch (std::exception& e) {
47896       {
47897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47898       };
47899     } catch (...) {
47900       {
47901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47902       };
47903     }
47904   }
47905
47906
47907 }
47908
47909
47910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
47911   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47912   Dali::Vector< unsigned char > *arg2 = 0 ;
47913
47914   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47915   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47916   if (!arg2) {
47917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
47918     return ;
47919   }
47920   {
47921     try {
47922       (arg1)->Swap(*arg2);
47923     } catch (std::out_of_range& e) {
47924       {
47925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47926       };
47927     } catch (std::exception& e) {
47928       {
47929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47930       };
47931     } catch (...) {
47932       {
47933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47934       };
47935     }
47936   }
47937 }
47938
47939
47940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
47941   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47942
47943   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47944   {
47945     try {
47946       (arg1)->Clear();
47947     } catch (std::out_of_range& e) {
47948       {
47949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47950       };
47951     } catch (std::exception& e) {
47952       {
47953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47954       };
47955     } catch (...) {
47956       {
47957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47958       };
47959     }
47960   }
47961 }
47962
47963
47964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
47965   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47966
47967   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47968   {
47969     try {
47970       (arg1)->Release();
47971     } catch (std::out_of_range& e) {
47972       {
47973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47974       };
47975     } catch (std::exception& e) {
47976       {
47977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47978       };
47979     } catch (...) {
47980       {
47981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47982       };
47983     }
47984   }
47985 }
47986
47987
47988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
47989   int jresult ;
47990   int result;
47991
47992   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
47993   jresult = (int)result;
47994   return jresult;
47995 }
47996
47997
47998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
47999   void * jresult ;
48000   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48001
48002   {
48003     try {
48004       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
48005     } catch (std::out_of_range& e) {
48006       {
48007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48008       };
48009     } catch (std::exception& e) {
48010       {
48011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48012       };
48013     } catch (...) {
48014       {
48015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48016       };
48017     }
48018   }
48019   jresult = (void *)result;
48020   return jresult;
48021 }
48022
48023
48024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
48025   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48026
48027   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48028   {
48029     try {
48030       delete arg1;
48031     } catch (std::out_of_range& e) {
48032       {
48033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48034       };
48035     } catch (std::exception& e) {
48036       {
48037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48038       };
48039     } catch (...) {
48040       {
48041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48042       };
48043     }
48044   }
48045 }
48046
48047
48048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48049   void * jresult ;
48050   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48051   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48052
48053   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48054   if (!arg1) {
48055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48056     return 0;
48057   }
48058   {
48059     try {
48060       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48061     } catch (std::out_of_range& e) {
48062       {
48063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48064       };
48065     } catch (std::exception& e) {
48066       {
48067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48068       };
48069     } catch (...) {
48070       {
48071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48072       };
48073     }
48074   }
48075   jresult = (void *)result;
48076   return jresult;
48077 }
48078
48079
48080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48081   void * jresult ;
48082   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48083   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48084   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48085
48086   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48087   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48088   if (!arg2) {
48089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48090     return 0;
48091   }
48092   {
48093     try {
48094       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48095     } catch (std::out_of_range& e) {
48096       {
48097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48098       };
48099     } catch (std::exception& e) {
48100       {
48101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48102       };
48103     } catch (...) {
48104       {
48105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48106       };
48107     }
48108   }
48109   jresult = (void *)result;
48110   return jresult;
48111 }
48112
48113
48114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48115   void * jresult ;
48116   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48117   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48118
48119   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48120   {
48121     try {
48122       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48123     } catch (std::out_of_range& e) {
48124       {
48125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48126       };
48127     } catch (std::exception& e) {
48128       {
48129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48130       };
48131     } catch (...) {
48132       {
48133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48134       };
48135     }
48136   }
48137   jresult = (void *)result;
48138   return jresult;
48139 }
48140
48141
48142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48143   void * jresult ;
48144   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48145   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48146
48147   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48148   {
48149     try {
48150       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48151     } catch (std::out_of_range& e) {
48152       {
48153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48154       };
48155     } catch (std::exception& e) {
48156       {
48157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48158       };
48159     } catch (...) {
48160       {
48161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48162       };
48163     }
48164   }
48165   jresult = (void *)result;
48166   return jresult;
48167 }
48168
48169
48170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48171   void * jresult ;
48172   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48173   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48174   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48175
48176   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48177   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48178   {
48179     try {
48180       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48181     } catch (std::out_of_range& e) {
48182       {
48183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48184       };
48185     } catch (std::exception& e) {
48186       {
48187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48188       };
48189     } catch (...) {
48190       {
48191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48192       };
48193     }
48194   }
48195   jresult = (void *)result;
48196   return jresult;
48197 }
48198
48199
48200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48201   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48202   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48203
48204   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48205   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48206   if (!arg2) {
48207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48208     return ;
48209   }
48210   {
48211     try {
48212       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48213     } catch (std::out_of_range& e) {
48214       {
48215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48216       };
48217     } catch (std::exception& e) {
48218       {
48219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48220       };
48221     } catch (...) {
48222       {
48223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48224       };
48225     }
48226   }
48227 }
48228
48229
48230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48231   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48232   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48233   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48234
48235   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48236   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48237   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48238   if (!arg3) {
48239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48240     return ;
48241   }
48242   {
48243     try {
48244       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48245     } catch (std::out_of_range& e) {
48246       {
48247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48248       };
48249     } catch (std::exception& e) {
48250       {
48251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48252       };
48253     } catch (...) {
48254       {
48255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48256       };
48257     }
48258   }
48259 }
48260
48261
48262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48263   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48264   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48265   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48266   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48267
48268   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48269   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48270   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48271   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48272   {
48273     try {
48274       (arg1)->Insert(arg2,arg3,arg4);
48275     } catch (std::out_of_range& e) {
48276       {
48277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48278       };
48279     } catch (std::exception& e) {
48280       {
48281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48282       };
48283     } catch (...) {
48284       {
48285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48286       };
48287     }
48288   }
48289 }
48290
48291
48292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48293   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48294   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48295
48296   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48297   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48298   {
48299     try {
48300       (arg1)->Reserve(arg2);
48301     } catch (std::out_of_range& e) {
48302       {
48303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48304       };
48305     } catch (std::exception& e) {
48306       {
48307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48308       };
48309     } catch (...) {
48310       {
48311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48312       };
48313     }
48314   }
48315 }
48316
48317
48318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48319   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48320   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48321
48322   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48323   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48324   {
48325     try {
48326       (arg1)->Resize(arg2);
48327     } catch (std::out_of_range& e) {
48328       {
48329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48330       };
48331     } catch (std::exception& e) {
48332       {
48333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48334       };
48335     } catch (...) {
48336       {
48337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48338       };
48339     }
48340   }
48341 }
48342
48343
48344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48345   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48346   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48347   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48348
48349   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48350   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48351   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48352   if (!arg3) {
48353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48354     return ;
48355   }
48356   {
48357     try {
48358       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48359     } catch (std::out_of_range& e) {
48360       {
48361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48362       };
48363     } catch (std::exception& e) {
48364       {
48365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48366       };
48367     } catch (...) {
48368       {
48369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48370       };
48371     }
48372   }
48373 }
48374
48375
48376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48377   void * jresult ;
48378   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48379   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48380   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48381
48382   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48383   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48384   {
48385     try {
48386       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48387     } catch (std::out_of_range& e) {
48388       {
48389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48390       };
48391     } catch (std::exception& e) {
48392       {
48393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48394       };
48395     } catch (...) {
48396       {
48397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48398       };
48399     }
48400   }
48401   jresult = (void *)result;
48402   return jresult;
48403 }
48404
48405
48406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48407   void * jresult ;
48408   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48409   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48410   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48411   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48412
48413   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48414   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48415   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48416   {
48417     try {
48418       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48419     } catch (std::out_of_range& e) {
48420       {
48421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48422       };
48423     } catch (std::exception& e) {
48424       {
48425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48426       };
48427     } catch (...) {
48428       {
48429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48430       };
48431     }
48432   }
48433   jresult = (void *)result;
48434   return jresult;
48435 }
48436
48437
48438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48439   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48440   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48441
48442   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48443   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48444   {
48445     try {
48446       (arg1)->Remove(arg2);
48447     } catch (std::out_of_range& e) {
48448       {
48449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48450       };
48451     } catch (std::exception& e) {
48452       {
48453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48454       };
48455     } catch (...) {
48456       {
48457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48458       };
48459     }
48460   }
48461 }
48462
48463
48464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48465   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48466   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48467
48468   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48469   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48470   if (!arg2) {
48471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48472     return ;
48473   }
48474   {
48475     try {
48476       (arg1)->Swap(*arg2);
48477     } catch (std::out_of_range& e) {
48478       {
48479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48480       };
48481     } catch (std::exception& e) {
48482       {
48483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48484       };
48485     } catch (...) {
48486       {
48487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48488       };
48489     }
48490   }
48491 }
48492
48493
48494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48495   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48496
48497   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48498   {
48499     try {
48500       (arg1)->Clear();
48501     } catch (std::out_of_range& e) {
48502       {
48503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48504       };
48505     } catch (std::exception& e) {
48506       {
48507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48508       };
48509     } catch (...) {
48510       {
48511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48512       };
48513     }
48514   }
48515 }
48516
48517
48518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48519   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48520
48521   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48522   {
48523     try {
48524       (arg1)->Release();
48525     } catch (std::out_of_range& e) {
48526       {
48527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48528       };
48529     } catch (std::exception& e) {
48530       {
48531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48532       };
48533     } catch (...) {
48534       {
48535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48536       };
48537     }
48538   }
48539 }
48540
48541
48542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48543   void * jresult ;
48544   Dali::Signal< void () > *result = 0 ;
48545
48546   {
48547     try {
48548       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48549     } catch (std::out_of_range& e) {
48550       {
48551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48552       };
48553     } catch (std::exception& e) {
48554       {
48555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48556       };
48557     } catch (...) {
48558       {
48559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48560       };
48561     }
48562   }
48563   jresult = (void *)result;
48564   return jresult;
48565 }
48566
48567
48568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48569   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48570
48571   arg1 = (Dali::Signal< void () > *)jarg1;
48572   {
48573     try {
48574       delete arg1;
48575     } catch (std::out_of_range& e) {
48576       {
48577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48578       };
48579     } catch (std::exception& e) {
48580       {
48581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48582       };
48583     } catch (...) {
48584       {
48585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48586       };
48587     }
48588   }
48589 }
48590
48591
48592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48593   unsigned int jresult ;
48594   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48595   bool result;
48596
48597   arg1 = (Dali::Signal< void () > *)jarg1;
48598   {
48599     try {
48600       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48601     } catch (std::out_of_range& e) {
48602       {
48603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48604       };
48605     } catch (std::exception& e) {
48606       {
48607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48608       };
48609     } catch (...) {
48610       {
48611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48612       };
48613     }
48614   }
48615   jresult = result;
48616   return jresult;
48617 }
48618
48619
48620 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48621   unsigned long jresult ;
48622   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48623   std::size_t result;
48624
48625   arg1 = (Dali::Signal< void () > *)jarg1;
48626   {
48627     try {
48628       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48629     } catch (std::out_of_range& e) {
48630       {
48631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48632       };
48633     } catch (std::exception& e) {
48634       {
48635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48636       };
48637     } catch (...) {
48638       {
48639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48640       };
48641     }
48642   }
48643   jresult = (unsigned long)result;
48644   return jresult;
48645 }
48646
48647
48648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48649   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48650   void (*arg2)() = (void (*)()) 0 ;
48651
48652   arg1 = (Dali::Signal< void () > *)jarg1;
48653   arg2 = (void (*)())jarg2;
48654   {
48655     try {
48656       (arg1)->Connect(arg2);
48657     } catch (std::out_of_range& e) {
48658       {
48659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48660       };
48661     } catch (std::exception& e) {
48662       {
48663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48664       };
48665     } catch (...) {
48666       {
48667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48668       };
48669     }
48670   }
48671 }
48672
48673
48674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48675   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48676   void (*arg2)() = (void (*)()) 0 ;
48677
48678   arg1 = (Dali::Signal< void () > *)jarg1;
48679   arg2 = (void (*)())jarg2;
48680   {
48681     try {
48682       (arg1)->Disconnect(arg2);
48683     } catch (std::out_of_range& e) {
48684       {
48685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48686       };
48687     } catch (std::exception& e) {
48688       {
48689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48690       };
48691     } catch (...) {
48692       {
48693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48694       };
48695     }
48696   }
48697 }
48698
48699
48700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48701   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48702   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48703   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48704
48705   arg1 = (Dali::Signal< void () > *)jarg1;
48706   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48707   arg3 = (Dali::FunctorDelegate *)jarg3;
48708   {
48709     try {
48710       (arg1)->Connect(arg2,arg3);
48711     } catch (std::out_of_range& e) {
48712       {
48713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48714       };
48715     } catch (std::exception& e) {
48716       {
48717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48718       };
48719     } catch (...) {
48720       {
48721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48722       };
48723     }
48724   }
48725 }
48726
48727
48728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48729   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48730
48731   arg1 = (Dali::Signal< void () > *)jarg1;
48732   {
48733     try {
48734       (arg1)->Emit();
48735     } catch (std::out_of_range& e) {
48736       {
48737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48738       };
48739     } catch (std::exception& e) {
48740       {
48741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48742       };
48743     } catch (...) {
48744       {
48745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48746       };
48747     }
48748   }
48749 }
48750
48751
48752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48753   unsigned int jresult ;
48754   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48755   bool result;
48756
48757   arg1 = (Dali::Signal< void (float) > *)jarg1;
48758   {
48759     try {
48760       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48761     } catch (std::out_of_range& e) {
48762       {
48763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48764       };
48765     } catch (std::exception& e) {
48766       {
48767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48768       };
48769     } catch (...) {
48770       {
48771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48772       };
48773     }
48774   }
48775   jresult = result;
48776   return jresult;
48777 }
48778
48779
48780 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48781   unsigned long jresult ;
48782   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48783   std::size_t result;
48784
48785   arg1 = (Dali::Signal< void (float) > *)jarg1;
48786   {
48787     try {
48788       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48789     } catch (std::out_of_range& e) {
48790       {
48791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48792       };
48793     } catch (std::exception& e) {
48794       {
48795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48796       };
48797     } catch (...) {
48798       {
48799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48800       };
48801     }
48802   }
48803   jresult = (unsigned long)result;
48804   return jresult;
48805 }
48806
48807
48808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
48809   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48810   void (*arg2)(float) = (void (*)(float)) 0 ;
48811
48812   arg1 = (Dali::Signal< void (float) > *)jarg1;
48813   arg2 = (void (*)(float))jarg2;
48814   {
48815     try {
48816       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
48817     } catch (std::out_of_range& e) {
48818       {
48819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48820       };
48821     } catch (std::exception& e) {
48822       {
48823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48824       };
48825     } catch (...) {
48826       {
48827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48828       };
48829     }
48830   }
48831 }
48832
48833
48834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
48835   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48836   void (*arg2)(float) = (void (*)(float)) 0 ;
48837
48838   arg1 = (Dali::Signal< void (float) > *)jarg1;
48839   arg2 = (void (*)(float))jarg2;
48840   {
48841     try {
48842       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
48843     } catch (std::out_of_range& e) {
48844       {
48845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48846       };
48847     } catch (std::exception& e) {
48848       {
48849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48850       };
48851     } catch (...) {
48852       {
48853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48854       };
48855     }
48856   }
48857 }
48858
48859
48860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
48861   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48862   float arg2 ;
48863
48864   arg1 = (Dali::Signal< void (float) > *)jarg1;
48865   arg2 = (float)jarg2;
48866   {
48867     try {
48868       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
48869     } catch (std::out_of_range& e) {
48870       {
48871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48872       };
48873     } catch (std::exception& e) {
48874       {
48875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48876       };
48877     } catch (...) {
48878       {
48879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48880       };
48881     }
48882   }
48883 }
48884
48885
48886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
48887   void * jresult ;
48888   Dali::Signal< void (float) > *result = 0 ;
48889
48890   {
48891     try {
48892       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
48893     } catch (std::out_of_range& e) {
48894       {
48895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48896       };
48897     } catch (std::exception& e) {
48898       {
48899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48900       };
48901     } catch (...) {
48902       {
48903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48904       };
48905     }
48906   }
48907   jresult = (void *)result;
48908   return jresult;
48909 }
48910
48911
48912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
48913   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48914
48915   arg1 = (Dali::Signal< void (float) > *)jarg1;
48916   {
48917     try {
48918       delete arg1;
48919     } catch (std::out_of_range& e) {
48920       {
48921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48922       };
48923     } catch (std::exception& e) {
48924       {
48925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48926       };
48927     } catch (...) {
48928       {
48929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48930       };
48931     }
48932   }
48933 }
48934
48935
48936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
48937   unsigned int jresult ;
48938   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48939   bool result;
48940
48941   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48942   {
48943     try {
48944       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48945     } catch (std::out_of_range& e) {
48946       {
48947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48948       };
48949     } catch (std::exception& e) {
48950       {
48951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48952       };
48953     } catch (...) {
48954       {
48955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48956       };
48957     }
48958   }
48959   jresult = result;
48960   return jresult;
48961 }
48962
48963
48964 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
48965   unsigned long jresult ;
48966   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48967   std::size_t result;
48968
48969   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48970   {
48971     try {
48972       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
48973     } catch (std::out_of_range& e) {
48974       {
48975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48976       };
48977     } catch (std::exception& e) {
48978       {
48979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48980       };
48981     } catch (...) {
48982       {
48983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48984       };
48985     }
48986   }
48987   jresult = (unsigned long)result;
48988   return jresult;
48989 }
48990
48991
48992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
48993   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
48994   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
48995
48996   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
48997   arg2 = (void (*)(Dali::BaseHandle))jarg2;
48998   {
48999     try {
49000       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49001     } catch (std::out_of_range& e) {
49002       {
49003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49004       };
49005     } catch (std::exception& e) {
49006       {
49007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49008       };
49009     } catch (...) {
49010       {
49011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49012       };
49013     }
49014   }
49015 }
49016
49017
49018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49019   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49020   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49021
49022   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49023   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49024   {
49025     try {
49026       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49027     } catch (std::out_of_range& e) {
49028       {
49029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49030       };
49031     } catch (std::exception& e) {
49032       {
49033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49034       };
49035     } catch (...) {
49036       {
49037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49038       };
49039     }
49040   }
49041 }
49042
49043
49044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49045   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49046   Dali::BaseHandle arg2 ;
49047   Dali::BaseHandle *argp2 ;
49048
49049   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49050   argp2 = (Dali::BaseHandle *)jarg2;
49051   if (!argp2) {
49052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49053     return ;
49054   }
49055   arg2 = *argp2;
49056   {
49057     try {
49058       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49059     } catch (std::out_of_range& e) {
49060       {
49061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49062       };
49063     } catch (std::exception& e) {
49064       {
49065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49066       };
49067     } catch (...) {
49068       {
49069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49070       };
49071     }
49072   }
49073 }
49074
49075
49076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49077   void * jresult ;
49078   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49079
49080   {
49081     try {
49082       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49083     } catch (std::out_of_range& e) {
49084       {
49085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49086       };
49087     } catch (std::exception& e) {
49088       {
49089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49090       };
49091     } catch (...) {
49092       {
49093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49094       };
49095     }
49096   }
49097   jresult = (void *)result;
49098   return jresult;
49099 }
49100
49101
49102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49103   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49104
49105   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49106   {
49107     try {
49108       delete arg1;
49109     } catch (std::out_of_range& e) {
49110       {
49111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49112       };
49113     } catch (std::exception& e) {
49114       {
49115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49116       };
49117     } catch (...) {
49118       {
49119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49120       };
49121     }
49122   }
49123 }
49124
49125
49126 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49127   unsigned int jresult ;
49128   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49129   bool result;
49130
49131   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49132   {
49133     try {
49134       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49135     } catch (std::out_of_range& e) {
49136       {
49137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49138       };
49139     } catch (std::exception& e) {
49140       {
49141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49142       };
49143     } catch (...) {
49144       {
49145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49146       };
49147     }
49148   }
49149   jresult = result;
49150   return jresult;
49151 }
49152
49153
49154 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49155   unsigned long jresult ;
49156   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49157   std::size_t result;
49158
49159   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49160   {
49161     try {
49162       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49163     } catch (std::out_of_range& e) {
49164       {
49165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49166       };
49167     } catch (std::exception& e) {
49168       {
49169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49170       };
49171     } catch (...) {
49172       {
49173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49174       };
49175     }
49176   }
49177   jresult = (unsigned long)result;
49178   return jresult;
49179 }
49180
49181
49182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49183   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49184   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49185
49186   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49187   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49188   {
49189     try {
49190       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49191     } catch (std::out_of_range& e) {
49192       {
49193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49194       };
49195     } catch (std::exception& e) {
49196       {
49197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49198       };
49199     } catch (...) {
49200       {
49201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49202       };
49203     }
49204   }
49205 }
49206
49207
49208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49209   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49210   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49211
49212   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49213   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49214   {
49215     try {
49216       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49217     } catch (std::out_of_range& e) {
49218       {
49219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49220       };
49221     } catch (std::exception& e) {
49222       {
49223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49224       };
49225     } catch (...) {
49226       {
49227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49228       };
49229     }
49230   }
49231 }
49232
49233
49234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49235   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49236   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49237
49238   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49239   arg2 = (Dali::RefObject *)jarg2;
49240   {
49241     try {
49242       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49243     } catch (std::out_of_range& e) {
49244       {
49245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49246       };
49247     } catch (std::exception& e) {
49248       {
49249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49250       };
49251     } catch (...) {
49252       {
49253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49254       };
49255     }
49256   }
49257 }
49258
49259
49260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49261   void * jresult ;
49262   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49263
49264   {
49265     try {
49266       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49267     } catch (std::out_of_range& e) {
49268       {
49269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49270       };
49271     } catch (std::exception& e) {
49272       {
49273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49274       };
49275     } catch (...) {
49276       {
49277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49278       };
49279     }
49280   }
49281   jresult = (void *)result;
49282   return jresult;
49283 }
49284
49285
49286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49287   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49288
49289   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49290   {
49291     try {
49292       delete arg1;
49293     } catch (std::out_of_range& e) {
49294       {
49295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49296       };
49297     } catch (std::exception& e) {
49298       {
49299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49300       };
49301     } catch (...) {
49302       {
49303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49304       };
49305     }
49306   }
49307 }
49308
49309
49310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49311   unsigned int jresult ;
49312   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49313   bool result;
49314
49315   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49316   {
49317     try {
49318       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
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 (...) {
49328       {
49329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49330       };
49331     }
49332   }
49333   jresult = result;
49334   return jresult;
49335 }
49336
49337
49338 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49339   unsigned long jresult ;
49340   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49341   std::size_t result;
49342
49343   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49344   {
49345     try {
49346       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49347     } catch (std::out_of_range& e) {
49348       {
49349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49350       };
49351     } catch (std::exception& e) {
49352       {
49353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49354       };
49355     } catch (...) {
49356       {
49357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49358       };
49359     }
49360   }
49361   jresult = (unsigned long)result;
49362   return jresult;
49363 }
49364
49365
49366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49367   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49368   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49369
49370   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49371   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49372   {
49373     try {
49374       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49375     } catch (std::out_of_range& e) {
49376       {
49377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49378       };
49379     } catch (std::exception& e) {
49380       {
49381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49382       };
49383     } catch (...) {
49384       {
49385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49386       };
49387     }
49388   }
49389 }
49390
49391
49392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49393   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49394   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49395
49396   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49397   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49398   {
49399     try {
49400       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49401     } catch (std::out_of_range& e) {
49402       {
49403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49404       };
49405     } catch (std::exception& e) {
49406       {
49407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49408       };
49409     } catch (...) {
49410       {
49411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49412       };
49413     }
49414   }
49415 }
49416
49417
49418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49419   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49420   Dali::PropertyNotification *arg2 = 0 ;
49421
49422   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49423   arg2 = (Dali::PropertyNotification *)jarg2;
49424   if (!arg2) {
49425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49426     return ;
49427   }
49428   {
49429     try {
49430       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49431     } catch (std::out_of_range& e) {
49432       {
49433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49434       };
49435     } catch (std::exception& e) {
49436       {
49437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49438       };
49439     } catch (...) {
49440       {
49441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49442       };
49443     }
49444   }
49445 }
49446
49447
49448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49449   void * jresult ;
49450   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49451
49452   {
49453     try {
49454       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49455     } catch (std::out_of_range& e) {
49456       {
49457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49458       };
49459     } catch (std::exception& e) {
49460       {
49461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49462       };
49463     } catch (...) {
49464       {
49465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49466       };
49467     }
49468   }
49469   jresult = (void *)result;
49470   return jresult;
49471 }
49472
49473
49474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49475   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49476
49477   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49478   {
49479     try {
49480       delete arg1;
49481     } catch (std::out_of_range& e) {
49482       {
49483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49484       };
49485     } catch (std::exception& e) {
49486       {
49487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49488       };
49489     } catch (...) {
49490       {
49491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49492       };
49493     }
49494   }
49495 }
49496
49497
49498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49499   unsigned int jresult ;
49500   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49501   bool result;
49502
49503   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49504   {
49505     try {
49506       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49507     } catch (std::out_of_range& e) {
49508       {
49509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49510       };
49511     } catch (std::exception& e) {
49512       {
49513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49514       };
49515     } catch (...) {
49516       {
49517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49518       };
49519     }
49520   }
49521   jresult = result;
49522   return jresult;
49523 }
49524
49525
49526 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49527   unsigned long jresult ;
49528   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49529   std::size_t result;
49530
49531   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49532   {
49533     try {
49534       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49535     } catch (std::out_of_range& e) {
49536       {
49537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49538       };
49539     } catch (std::exception& e) {
49540       {
49541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49542       };
49543     } catch (...) {
49544       {
49545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49546       };
49547     }
49548   }
49549   jresult = (unsigned long)result;
49550   return jresult;
49551 }
49552
49553
49554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49555   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49556   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49557
49558   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49559   arg2 = (void (*)(Dali::Image))jarg2;
49560   {
49561     try {
49562       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49563     } catch (std::out_of_range& e) {
49564       {
49565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49566       };
49567     } catch (std::exception& e) {
49568       {
49569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49570       };
49571     } catch (...) {
49572       {
49573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49574       };
49575     }
49576   }
49577 }
49578
49579
49580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49581   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49582   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49583
49584   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49585   arg2 = (void (*)(Dali::Image))jarg2;
49586   {
49587     try {
49588       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49589     } catch (std::out_of_range& e) {
49590       {
49591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49592       };
49593     } catch (std::exception& e) {
49594       {
49595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49596       };
49597     } catch (...) {
49598       {
49599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49600       };
49601     }
49602   }
49603 }
49604
49605
49606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49607   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49608   Dali::Image arg2 ;
49609   Dali::Image *argp2 ;
49610
49611   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49612   argp2 = (Dali::Image *)jarg2;
49613   if (!argp2) {
49614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49615     return ;
49616   }
49617   arg2 = *argp2;
49618   {
49619     try {
49620       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49621     } catch (std::out_of_range& e) {
49622       {
49623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49624       };
49625     } catch (std::exception& e) {
49626       {
49627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49628       };
49629     } catch (...) {
49630       {
49631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49632       };
49633     }
49634   }
49635 }
49636
49637
49638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49639   void * jresult ;
49640   Dali::Signal< void (Dali::Image) > *result = 0 ;
49641
49642   {
49643     try {
49644       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49645     } catch (std::out_of_range& e) {
49646       {
49647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49648       };
49649     } catch (std::exception& e) {
49650       {
49651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49652       };
49653     } catch (...) {
49654       {
49655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49656       };
49657     }
49658   }
49659   jresult = (void *)result;
49660   return jresult;
49661 }
49662
49663
49664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49665   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49666
49667   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49668   {
49669     try {
49670       delete arg1;
49671     } catch (std::out_of_range& e) {
49672       {
49673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49674       };
49675     } catch (std::exception& e) {
49676       {
49677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49678       };
49679     } catch (...) {
49680       {
49681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49682       };
49683     }
49684   }
49685 }
49686
49687
49688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49689   void * jresult ;
49690   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49691
49692   {
49693     try {
49694       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49695     } catch (std::out_of_range& e) {
49696       {
49697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49698       };
49699     } catch (std::exception& e) {
49700       {
49701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49702       };
49703     } catch (...) {
49704       {
49705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49706       };
49707     }
49708   }
49709   jresult = (void *)result;
49710   return jresult;
49711 }
49712
49713
49714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49715   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49716
49717   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49718   {
49719     try {
49720       delete arg1;
49721     } catch (std::out_of_range& e) {
49722       {
49723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49724       };
49725     } catch (std::exception& e) {
49726       {
49727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49728       };
49729     } catch (...) {
49730       {
49731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49732       };
49733     }
49734   }
49735 }
49736
49737
49738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49739   unsigned int jresult ;
49740   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49741   bool result;
49742
49743   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49744   {
49745     try {
49746       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);
49747     } catch (std::out_of_range& e) {
49748       {
49749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49750       };
49751     } catch (std::exception& e) {
49752       {
49753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49754       };
49755     } catch (...) {
49756       {
49757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49758       };
49759     }
49760   }
49761   jresult = result;
49762   return jresult;
49763 }
49764
49765
49766 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49767   unsigned long jresult ;
49768   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49769   std::size_t result;
49770
49771   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49772   {
49773     try {
49774       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);
49775     } catch (std::out_of_range& e) {
49776       {
49777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49778       };
49779     } catch (std::exception& e) {
49780       {
49781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49782       };
49783     } catch (...) {
49784       {
49785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49786       };
49787     }
49788   }
49789   jresult = (unsigned long)result;
49790   return jresult;
49791 }
49792
49793
49794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49795   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49796   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49797
49798   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49799   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49800   {
49801     try {
49802       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49803     } catch (std::out_of_range& e) {
49804       {
49805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49806       };
49807     } catch (std::exception& e) {
49808       {
49809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49810       };
49811     } catch (...) {
49812       {
49813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49814       };
49815     }
49816   }
49817 }
49818
49819
49820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49821   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49822   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49823
49824   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49825   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49826   {
49827     try {
49828       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
49829     } catch (std::out_of_range& e) {
49830       {
49831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49832       };
49833     } catch (std::exception& e) {
49834       {
49835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49836       };
49837     } catch (...) {
49838       {
49839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49840       };
49841     }
49842   }
49843 }
49844
49845
49846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
49847   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49848   Dali::Actor arg2 ;
49849   Dali::LongPressGesture *arg3 = 0 ;
49850   Dali::Actor *argp2 ;
49851
49852   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49853   argp2 = (Dali::Actor *)jarg2;
49854   if (!argp2) {
49855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
49856     return ;
49857   }
49858   arg2 = *argp2;
49859   arg3 = (Dali::LongPressGesture *)jarg3;
49860   if (!arg3) {
49861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
49862     return ;
49863   }
49864   {
49865     try {
49866       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
49867     } catch (std::out_of_range& e) {
49868       {
49869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49870       };
49871     } catch (std::exception& e) {
49872       {
49873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49874       };
49875     } catch (...) {
49876       {
49877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49878       };
49879     }
49880   }
49881 }
49882
49883
49884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
49885   void * jresult ;
49886   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
49887
49888   {
49889     try {
49890       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
49891     } catch (std::out_of_range& e) {
49892       {
49893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49894       };
49895     } catch (std::exception& e) {
49896       {
49897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49898       };
49899     } catch (...) {
49900       {
49901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49902       };
49903     }
49904   }
49905   jresult = (void *)result;
49906   return jresult;
49907 }
49908
49909
49910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
49911   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49912
49913   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49914   {
49915     try {
49916       delete arg1;
49917     } catch (std::out_of_range& e) {
49918       {
49919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49920       };
49921     } catch (std::exception& e) {
49922       {
49923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49924       };
49925     } catch (...) {
49926       {
49927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49928       };
49929     }
49930   }
49931 }
49932
49933
49934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
49935   unsigned int jresult ;
49936   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49937   bool result;
49938
49939   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49940   {
49941     try {
49942       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);
49943     } catch (std::out_of_range& e) {
49944       {
49945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49946       };
49947     } catch (std::exception& e) {
49948       {
49949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49950       };
49951     } catch (...) {
49952       {
49953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49954       };
49955     }
49956   }
49957   jresult = result;
49958   return jresult;
49959 }
49960
49961
49962 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
49963   unsigned long jresult ;
49964   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49965   std::size_t result;
49966
49967   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49968   {
49969     try {
49970       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);
49971     } catch (std::out_of_range& e) {
49972       {
49973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49974       };
49975     } catch (std::exception& e) {
49976       {
49977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49978       };
49979     } catch (...) {
49980       {
49981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49982       };
49983     }
49984   }
49985   jresult = (unsigned long)result;
49986   return jresult;
49987 }
49988
49989
49990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
49991   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
49992   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
49993
49994   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
49995   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
49996   {
49997     try {
49998       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49999     } catch (std::out_of_range& e) {
50000       {
50001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50002       };
50003     } catch (std::exception& e) {
50004       {
50005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50006       };
50007     } catch (...) {
50008       {
50009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50010       };
50011     }
50012   }
50013 }
50014
50015
50016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50017   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50018   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50019
50020   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50021   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50022   {
50023     try {
50024       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50025     } catch (std::out_of_range& e) {
50026       {
50027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50028       };
50029     } catch (std::exception& e) {
50030       {
50031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50032       };
50033     } catch (...) {
50034       {
50035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50036       };
50037     }
50038   }
50039 }
50040
50041
50042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50043   unsigned int jresult ;
50044   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50045   Dali::Actor arg2 ;
50046   Dali::TouchData *arg3 = 0 ;
50047   Dali::Actor *argp2 ;
50048   bool result;
50049
50050   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50051   argp2 = (Dali::Actor *)jarg2;
50052   if (!argp2) {
50053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50054     return 0;
50055   }
50056   arg2 = *argp2;
50057   arg3 = (Dali::TouchData *)jarg3;
50058   if (!arg3) {
50059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50060     return 0;
50061   }
50062   {
50063     try {
50064       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50065     } catch (std::out_of_range& e) {
50066       {
50067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50068       };
50069     } catch (std::exception& e) {
50070       {
50071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50072       };
50073     } catch (...) {
50074       {
50075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50076       };
50077     }
50078   }
50079   jresult = result;
50080   return jresult;
50081 }
50082
50083
50084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50085   void * jresult ;
50086   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50087
50088   {
50089     try {
50090       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50091     } catch (std::out_of_range& e) {
50092       {
50093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50094       };
50095     } catch (std::exception& e) {
50096       {
50097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50098       };
50099     } catch (...) {
50100       {
50101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50102       };
50103     }
50104   }
50105   jresult = (void *)result;
50106   return jresult;
50107 }
50108
50109
50110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50111   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50112
50113   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50114   {
50115     try {
50116       delete arg1;
50117     } catch (std::out_of_range& e) {
50118       {
50119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50120       };
50121     } catch (std::exception& e) {
50122       {
50123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50124       };
50125     } catch (...) {
50126       {
50127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50128       };
50129     }
50130   }
50131 }
50132
50133
50134 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50135   unsigned int jresult ;
50136   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50137   bool result;
50138
50139   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50140   {
50141     try {
50142       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);
50143     } catch (std::out_of_range& e) {
50144       {
50145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50146       };
50147     } catch (std::exception& e) {
50148       {
50149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50150       };
50151     } catch (...) {
50152       {
50153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50154       };
50155     }
50156   }
50157   jresult = result;
50158   return jresult;
50159 }
50160
50161
50162 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50163   unsigned long jresult ;
50164   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50165   std::size_t result;
50166
50167   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50168   {
50169     try {
50170       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);
50171     } catch (std::out_of_range& e) {
50172       {
50173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50174       };
50175     } catch (std::exception& e) {
50176       {
50177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50178       };
50179     } catch (...) {
50180       {
50181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50182       };
50183     }
50184   }
50185   jresult = (unsigned long)result;
50186   return jresult;
50187 }
50188
50189
50190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50191   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50192   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50193
50194   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50195   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50196   {
50197     try {
50198       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50199     } catch (std::out_of_range& e) {
50200       {
50201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50202       };
50203     } catch (std::exception& e) {
50204       {
50205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50206       };
50207     } catch (...) {
50208       {
50209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50210       };
50211     }
50212   }
50213 }
50214
50215
50216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50217   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50218   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50219
50220   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50221   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50222   {
50223     try {
50224       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50225     } catch (std::out_of_range& e) {
50226       {
50227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50228       };
50229     } catch (std::exception& e) {
50230       {
50231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50232       };
50233     } catch (...) {
50234       {
50235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50236       };
50237     }
50238   }
50239 }
50240
50241
50242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50243   unsigned int jresult ;
50244   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50245   Dali::Actor arg2 ;
50246   Dali::HoverEvent *arg3 = 0 ;
50247   Dali::Actor *argp2 ;
50248   bool result;
50249
50250   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50251   argp2 = (Dali::Actor *)jarg2;
50252   if (!argp2) {
50253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50254     return 0;
50255   }
50256   arg2 = *argp2;
50257   arg3 = (Dali::HoverEvent *)jarg3;
50258   if (!arg3) {
50259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50260     return 0;
50261   }
50262   {
50263     try {
50264       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50265     } catch (std::out_of_range& e) {
50266       {
50267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50268       };
50269     } catch (std::exception& e) {
50270       {
50271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50272       };
50273     } catch (...) {
50274       {
50275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50276       };
50277     }
50278   }
50279   jresult = result;
50280   return jresult;
50281 }
50282
50283
50284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50285   void * jresult ;
50286   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50287
50288   {
50289     try {
50290       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50291     } catch (std::out_of_range& e) {
50292       {
50293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50294       };
50295     } catch (std::exception& e) {
50296       {
50297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50298       };
50299     } catch (...) {
50300       {
50301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50302       };
50303     }
50304   }
50305   jresult = (void *)result;
50306   return jresult;
50307 }
50308
50309
50310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50311   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50312
50313   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50314   {
50315     try {
50316       delete arg1;
50317     } catch (std::out_of_range& e) {
50318       {
50319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50320       };
50321     } catch (std::exception& e) {
50322       {
50323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50324       };
50325     } catch (...) {
50326       {
50327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50328       };
50329     }
50330   }
50331 }
50332
50333
50334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50335   unsigned int jresult ;
50336   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50337   bool result;
50338
50339   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50340   {
50341     try {
50342       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);
50343     } catch (std::out_of_range& e) {
50344       {
50345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50346       };
50347     } catch (std::exception& e) {
50348       {
50349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50350       };
50351     } catch (...) {
50352       {
50353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50354       };
50355     }
50356   }
50357   jresult = result;
50358   return jresult;
50359 }
50360
50361
50362 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50363   unsigned long jresult ;
50364   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50365   std::size_t result;
50366
50367   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50368   {
50369     try {
50370       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);
50371     } catch (std::out_of_range& e) {
50372       {
50373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50374       };
50375     } catch (std::exception& e) {
50376       {
50377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50378       };
50379     } catch (...) {
50380       {
50381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50382       };
50383     }
50384   }
50385   jresult = (unsigned long)result;
50386   return jresult;
50387 }
50388
50389
50390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50391   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50392   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50393
50394   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50395   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50396   {
50397     try {
50398       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50399     } catch (std::out_of_range& e) {
50400       {
50401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50402       };
50403     } catch (std::exception& e) {
50404       {
50405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50406       };
50407     } catch (...) {
50408       {
50409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50410       };
50411     }
50412   }
50413 }
50414
50415
50416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50417   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50418   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50419
50420   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50421   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50422   {
50423     try {
50424       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50425     } catch (std::out_of_range& e) {
50426       {
50427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50428       };
50429     } catch (std::exception& e) {
50430       {
50431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50432       };
50433     } catch (...) {
50434       {
50435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50436       };
50437     }
50438   }
50439 }
50440
50441
50442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50443   unsigned int jresult ;
50444   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50445   Dali::Actor arg2 ;
50446   Dali::WheelEvent *arg3 = 0 ;
50447   Dali::Actor *argp2 ;
50448   bool result;
50449
50450   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50451   argp2 = (Dali::Actor *)jarg2;
50452   if (!argp2) {
50453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50454     return 0;
50455   }
50456   arg2 = *argp2;
50457   arg3 = (Dali::WheelEvent *)jarg3;
50458   if (!arg3) {
50459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50460     return 0;
50461   }
50462   {
50463     try {
50464       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50465     } catch (std::out_of_range& e) {
50466       {
50467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50468       };
50469     } catch (std::exception& e) {
50470       {
50471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50472       };
50473     } catch (...) {
50474       {
50475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50476       };
50477     }
50478   }
50479   jresult = result;
50480   return jresult;
50481 }
50482
50483
50484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50485   void * jresult ;
50486   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50487
50488   {
50489     try {
50490       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50491     } catch (std::out_of_range& e) {
50492       {
50493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50494       };
50495     } catch (std::exception& e) {
50496       {
50497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50498       };
50499     } catch (...) {
50500       {
50501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50502       };
50503     }
50504   }
50505   jresult = (void *)result;
50506   return jresult;
50507 }
50508
50509
50510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50511   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50512
50513   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50514   {
50515     try {
50516       delete arg1;
50517     } catch (std::out_of_range& e) {
50518       {
50519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50520       };
50521     } catch (std::exception& e) {
50522       {
50523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50524       };
50525     } catch (...) {
50526       {
50527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50528       };
50529     }
50530   }
50531 }
50532
50533
50534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50535   unsigned int jresult ;
50536   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50537   bool result;
50538
50539   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50540   {
50541     try {
50542       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50543     } catch (std::out_of_range& e) {
50544       {
50545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50546       };
50547     } catch (std::exception& e) {
50548       {
50549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50550       };
50551     } catch (...) {
50552       {
50553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50554       };
50555     }
50556   }
50557   jresult = result;
50558   return jresult;
50559 }
50560
50561
50562 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50563   unsigned long jresult ;
50564   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50565   std::size_t result;
50566
50567   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50568   {
50569     try {
50570       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50571     } catch (std::out_of_range& e) {
50572       {
50573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50574       };
50575     } catch (std::exception& e) {
50576       {
50577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50578       };
50579     } catch (...) {
50580       {
50581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50582       };
50583     }
50584   }
50585   jresult = (unsigned long)result;
50586   return jresult;
50587 }
50588
50589
50590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50591   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50592   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50593
50594   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50595   arg2 = (void (*)(Dali::Actor))jarg2;
50596   {
50597     try {
50598       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50599     } catch (std::out_of_range& e) {
50600       {
50601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50602       };
50603     } catch (std::exception& e) {
50604       {
50605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50606       };
50607     } catch (...) {
50608       {
50609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50610       };
50611     }
50612   }
50613 }
50614
50615
50616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50617   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50618   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50619
50620   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50621   arg2 = (void (*)(Dali::Actor))jarg2;
50622   {
50623     try {
50624       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50625     } catch (std::out_of_range& e) {
50626       {
50627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50628       };
50629     } catch (std::exception& e) {
50630       {
50631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50632       };
50633     } catch (...) {
50634       {
50635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50636       };
50637     }
50638   }
50639 }
50640
50641
50642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50643   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50644   Dali::Actor arg2 ;
50645   Dali::Actor *argp2 ;
50646
50647   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50648   argp2 = (Dali::Actor *)jarg2;
50649   if (!argp2) {
50650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50651     return ;
50652   }
50653   arg2 = *argp2;
50654   {
50655     try {
50656       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
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 (...) {
50666       {
50667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50668       };
50669     }
50670   }
50671 }
50672
50673
50674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50675   void * jresult ;
50676   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50677
50678   {
50679     try {
50680       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50681     } catch (std::out_of_range& e) {
50682       {
50683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50684       };
50685     } catch (std::exception& e) {
50686       {
50687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50688       };
50689     } catch (...) {
50690       {
50691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50692       };
50693     }
50694   }
50695   jresult = (void *)result;
50696   return jresult;
50697 }
50698
50699
50700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50701   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50702
50703   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50704   {
50705     try {
50706       delete arg1;
50707     } catch (std::out_of_range& e) {
50708       {
50709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50710       };
50711     } catch (std::exception& e) {
50712       {
50713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50714       };
50715     } catch (...) {
50716       {
50717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50718       };
50719     }
50720   }
50721 }
50722
50723
50724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50725   unsigned int jresult ;
50726   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50727   bool result;
50728
50729   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50730   {
50731     try {
50732       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50733     } catch (std::out_of_range& e) {
50734       {
50735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50736       };
50737     } catch (std::exception& e) {
50738       {
50739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50740       };
50741     } catch (...) {
50742       {
50743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50744       };
50745     }
50746   }
50747   jresult = result;
50748   return jresult;
50749 }
50750
50751
50752 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50753   unsigned long jresult ;
50754   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50755   std::size_t result;
50756
50757   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50758   {
50759     try {
50760       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50761     } catch (std::out_of_range& e) {
50762       {
50763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50764       };
50765     } catch (std::exception& e) {
50766       {
50767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50768       };
50769     } catch (...) {
50770       {
50771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50772       };
50773     }
50774   }
50775   jresult = (unsigned long)result;
50776   return jresult;
50777 }
50778
50779
50780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50781   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50782   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50783
50784   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50785   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50786   {
50787     try {
50788       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50789     } catch (std::out_of_range& e) {
50790       {
50791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50792       };
50793     } catch (std::exception& e) {
50794       {
50795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50796       };
50797     } catch (...) {
50798       {
50799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50800       };
50801     }
50802   }
50803 }
50804
50805
50806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
50807   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50808   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50809
50810   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50811   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50812   {
50813     try {
50814       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50815     } catch (std::out_of_range& e) {
50816       {
50817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50818       };
50819     } catch (std::exception& e) {
50820       {
50821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50822       };
50823     } catch (...) {
50824       {
50825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50826       };
50827     }
50828   }
50829 }
50830
50831
50832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
50833   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50834   Dali::KeyEvent *arg2 = 0 ;
50835
50836   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50837   arg2 = (Dali::KeyEvent *)jarg2;
50838   if (!arg2) {
50839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
50840     return ;
50841   }
50842   {
50843     try {
50844       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
50845     } catch (std::out_of_range& e) {
50846       {
50847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50848       };
50849     } catch (std::exception& e) {
50850       {
50851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50852       };
50853     } catch (...) {
50854       {
50855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50856       };
50857     }
50858   }
50859 }
50860
50861
50862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
50863   void * jresult ;
50864   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
50865
50866   {
50867     try {
50868       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
50869     } catch (std::out_of_range& e) {
50870       {
50871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50872       };
50873     } catch (std::exception& e) {
50874       {
50875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50876       };
50877     } catch (...) {
50878       {
50879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50880       };
50881     }
50882   }
50883   jresult = (void *)result;
50884   return jresult;
50885 }
50886
50887
50888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
50889   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50890
50891   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50892   {
50893     try {
50894       delete arg1;
50895     } catch (std::out_of_range& e) {
50896       {
50897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50898       };
50899     } catch (std::exception& e) {
50900       {
50901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50902       };
50903     } catch (...) {
50904       {
50905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50906       };
50907     }
50908   }
50909 }
50910
50911
50912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
50913   unsigned int jresult ;
50914   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50915   bool result;
50916
50917   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50918   {
50919     try {
50920       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50921     } catch (std::out_of_range& e) {
50922       {
50923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50924       };
50925     } catch (std::exception& e) {
50926       {
50927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50928       };
50929     } catch (...) {
50930       {
50931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50932       };
50933     }
50934   }
50935   jresult = result;
50936   return jresult;
50937 }
50938
50939
50940 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
50941   unsigned long jresult ;
50942   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50943   std::size_t result;
50944
50945   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50946   {
50947     try {
50948       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
50949     } catch (std::out_of_range& e) {
50950       {
50951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50952       };
50953     } catch (std::exception& e) {
50954       {
50955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50956       };
50957     } catch (...) {
50958       {
50959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50960       };
50961     }
50962   }
50963   jresult = (unsigned long)result;
50964   return jresult;
50965 }
50966
50967
50968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
50969   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50970   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
50971
50972   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50973   arg2 = (void (*)(Dali::TouchData const &))jarg2;
50974   {
50975     try {
50976       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50977     } catch (std::out_of_range& e) {
50978       {
50979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50980       };
50981     } catch (std::exception& e) {
50982       {
50983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50984       };
50985     } catch (...) {
50986       {
50987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50988       };
50989     }
50990   }
50991 }
50992
50993
50994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
50995   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
50996   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
50997
50998   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
50999   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51000   {
51001     try {
51002       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51003     } catch (std::out_of_range& e) {
51004       {
51005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51006       };
51007     } catch (std::exception& e) {
51008       {
51009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51010       };
51011     } catch (...) {
51012       {
51013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51014       };
51015     }
51016   }
51017 }
51018
51019
51020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51021   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51022   Dali::TouchData *arg2 = 0 ;
51023
51024   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51025   arg2 = (Dali::TouchData *)jarg2;
51026   if (!arg2) {
51027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51028     return ;
51029   }
51030   {
51031     try {
51032       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51033     } catch (std::out_of_range& e) {
51034       {
51035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51036       };
51037     } catch (std::exception& e) {
51038       {
51039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51040       };
51041     } catch (...) {
51042       {
51043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51044       };
51045     }
51046   }
51047 }
51048
51049
51050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51051   void * jresult ;
51052   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51053
51054   {
51055     try {
51056       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51057     } catch (std::out_of_range& e) {
51058       {
51059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51060       };
51061     } catch (std::exception& e) {
51062       {
51063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51064       };
51065     } catch (...) {
51066       {
51067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51068       };
51069     }
51070   }
51071   jresult = (void *)result;
51072   return jresult;
51073 }
51074
51075
51076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51077   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51078
51079   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51080   {
51081     try {
51082       delete arg1;
51083     } catch (std::out_of_range& e) {
51084       {
51085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51086       };
51087     } catch (std::exception& e) {
51088       {
51089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51090       };
51091     } catch (...) {
51092       {
51093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51094       };
51095     }
51096   }
51097 }
51098
51099
51100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51101   unsigned int jresult ;
51102   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51103   bool result;
51104
51105   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51106   {
51107     try {
51108       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51109     } catch (std::out_of_range& e) {
51110       {
51111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51112       };
51113     } catch (std::exception& e) {
51114       {
51115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51116       };
51117     } catch (...) {
51118       {
51119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51120       };
51121     }
51122   }
51123   jresult = result;
51124   return jresult;
51125 }
51126
51127
51128 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51129   unsigned long jresult ;
51130   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51131   std::size_t result;
51132
51133   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51134   {
51135     try {
51136       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51137     } catch (std::out_of_range& e) {
51138       {
51139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51140       };
51141     } catch (std::exception& e) {
51142       {
51143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51144       };
51145     } catch (...) {
51146       {
51147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51148       };
51149     }
51150   }
51151   jresult = (unsigned long)result;
51152   return jresult;
51153 }
51154
51155
51156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51157   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51158   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51159
51160   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51161   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51162   {
51163     try {
51164       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51165     } catch (std::out_of_range& e) {
51166       {
51167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51168       };
51169     } catch (std::exception& e) {
51170       {
51171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51172       };
51173     } catch (...) {
51174       {
51175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51176       };
51177     }
51178   }
51179 }
51180
51181
51182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51183   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51184   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51185
51186   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51187   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51188   {
51189     try {
51190       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51191     } catch (std::out_of_range& e) {
51192       {
51193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51194       };
51195     } catch (std::exception& e) {
51196       {
51197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51198       };
51199     } catch (...) {
51200       {
51201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51202       };
51203     }
51204   }
51205 }
51206
51207
51208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51209   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51210   Dali::WheelEvent *arg2 = 0 ;
51211
51212   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51213   arg2 = (Dali::WheelEvent *)jarg2;
51214   if (!arg2) {
51215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51216     return ;
51217   }
51218   {
51219     try {
51220       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51221     } catch (std::out_of_range& e) {
51222       {
51223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51224       };
51225     } catch (std::exception& e) {
51226       {
51227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51228       };
51229     } catch (...) {
51230       {
51231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51232       };
51233     }
51234   }
51235 }
51236
51237
51238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51239   void * jresult ;
51240   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51241
51242   {
51243     try {
51244       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51245     } catch (std::out_of_range& e) {
51246       {
51247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51248       };
51249     } catch (std::exception& e) {
51250       {
51251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51252       };
51253     } catch (...) {
51254       {
51255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51256       };
51257     }
51258   }
51259   jresult = (void *)result;
51260   return jresult;
51261 }
51262
51263
51264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51265   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51266
51267   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51268   {
51269     try {
51270       delete arg1;
51271     } catch (std::out_of_range& e) {
51272       {
51273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51274       };
51275     } catch (std::exception& e) {
51276       {
51277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51278       };
51279     } catch (...) {
51280       {
51281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51282       };
51283     }
51284   }
51285 }
51286
51287
51288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51289   void * jresult ;
51290   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51291
51292   {
51293     try {
51294       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51295     } catch (std::out_of_range& e) {
51296       {
51297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51298       };
51299     } catch (std::exception& e) {
51300       {
51301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51302       };
51303     } catch (...) {
51304       {
51305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51306       };
51307     }
51308   }
51309   jresult = (void *)result;
51310   return jresult;
51311 }
51312
51313
51314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51315   void * jresult ;
51316   Dali::Radian arg1 ;
51317   Dali::Radian arg2 ;
51318   Dali::Radian *argp1 ;
51319   Dali::Radian *argp2 ;
51320   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51321
51322   argp1 = (Dali::Radian *)jarg1;
51323   if (!argp1) {
51324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51325     return 0;
51326   }
51327   arg1 = *argp1;
51328   argp2 = (Dali::Radian *)jarg2;
51329   if (!argp2) {
51330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51331     return 0;
51332   }
51333   arg2 = *argp2;
51334   {
51335     try {
51336       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51337     } catch (std::out_of_range& e) {
51338       {
51339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51340       };
51341     } catch (std::exception& e) {
51342       {
51343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51344       };
51345     } catch (...) {
51346       {
51347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51348       };
51349     }
51350   }
51351   jresult = (void *)result;
51352   return jresult;
51353 }
51354
51355
51356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51357   void * jresult ;
51358   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51359   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51360
51361   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51362   if (!arg1) {
51363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51364     return 0;
51365   }
51366   {
51367     try {
51368       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51369     } catch (std::out_of_range& e) {
51370       {
51371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51372       };
51373     } catch (std::exception& e) {
51374       {
51375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51376       };
51377     } catch (...) {
51378       {
51379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51380       };
51381     }
51382   }
51383   jresult = (void *)result;
51384   return jresult;
51385 }
51386
51387
51388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51389   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51390   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51391
51392   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51393   arg2 = (Dali::Radian *)jarg2;
51394   if (arg1) (arg1)->first = *arg2;
51395 }
51396
51397
51398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51399   void * jresult ;
51400   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51401   Dali::Radian *result = 0 ;
51402
51403   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51404   result = (Dali::Radian *)& ((arg1)->first);
51405   jresult = (void *)result;
51406   return jresult;
51407 }
51408
51409
51410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51411   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51412   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51413
51414   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51415   arg2 = (Dali::Radian *)jarg2;
51416   if (arg1) (arg1)->second = *arg2;
51417 }
51418
51419
51420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51421   void * jresult ;
51422   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51423   Dali::Radian *result = 0 ;
51424
51425   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51426   result = (Dali::Radian *)& ((arg1)->second);
51427   jresult = (void *)result;
51428   return jresult;
51429 }
51430
51431
51432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51433   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51434
51435   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51436   {
51437     try {
51438       delete arg1;
51439     } catch (std::out_of_range& e) {
51440       {
51441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51442       };
51443     } catch (std::exception& e) {
51444       {
51445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51446       };
51447     } catch (...) {
51448       {
51449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51450       };
51451     }
51452   }
51453 }
51454
51455
51456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51457   unsigned int jresult ;
51458   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51459   bool result;
51460
51461   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51462   {
51463     try {
51464       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);
51465     } catch (std::out_of_range& e) {
51466       {
51467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51468       };
51469     } catch (std::exception& e) {
51470       {
51471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51472       };
51473     } catch (...) {
51474       {
51475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51476       };
51477     }
51478   }
51479   jresult = result;
51480   return jresult;
51481 }
51482
51483
51484 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51485   unsigned long jresult ;
51486   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51487   std::size_t result;
51488
51489   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51490   {
51491     try {
51492       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);
51493     } catch (std::out_of_range& e) {
51494       {
51495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51496       };
51497     } catch (std::exception& e) {
51498       {
51499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51500       };
51501     } catch (...) {
51502       {
51503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51504       };
51505     }
51506   }
51507   jresult = (unsigned long)result;
51508   return jresult;
51509 }
51510
51511
51512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51513   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51514   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51515
51516   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51517   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51518   {
51519     try {
51520       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51521     } catch (std::out_of_range& e) {
51522       {
51523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51524       };
51525     } catch (std::exception& e) {
51526       {
51527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51528       };
51529     } catch (...) {
51530       {
51531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51532       };
51533     }
51534   }
51535 }
51536
51537
51538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51539   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51540   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51541
51542   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51543   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51544   {
51545     try {
51546       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51547     } catch (std::out_of_range& e) {
51548       {
51549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51550       };
51551     } catch (std::exception& e) {
51552       {
51553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51554       };
51555     } catch (...) {
51556       {
51557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51558       };
51559     }
51560   }
51561 }
51562
51563
51564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51565   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51566   Dali::Actor arg2 ;
51567   Dali::PanGesture *arg3 = 0 ;
51568   Dali::Actor *argp2 ;
51569
51570   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51571   argp2 = (Dali::Actor *)jarg2;
51572   if (!argp2) {
51573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51574     return ;
51575   }
51576   arg2 = *argp2;
51577   arg3 = (Dali::PanGesture *)jarg3;
51578   if (!arg3) {
51579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51580     return ;
51581   }
51582   {
51583     try {
51584       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51585     } catch (std::out_of_range& e) {
51586       {
51587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51588       };
51589     } catch (std::exception& e) {
51590       {
51591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51592       };
51593     } catch (...) {
51594       {
51595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51596       };
51597     }
51598   }
51599 }
51600
51601
51602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51603   void * jresult ;
51604   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51605
51606   {
51607     try {
51608       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51609     } catch (std::out_of_range& e) {
51610       {
51611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51612       };
51613     } catch (std::exception& e) {
51614       {
51615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51616       };
51617     } catch (...) {
51618       {
51619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51620       };
51621     }
51622   }
51623   jresult = (void *)result;
51624   return jresult;
51625 }
51626
51627
51628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51629   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51630
51631   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51632   {
51633     try {
51634       delete arg1;
51635     } catch (std::out_of_range& e) {
51636       {
51637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51638       };
51639     } catch (std::exception& e) {
51640       {
51641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51642       };
51643     } catch (...) {
51644       {
51645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51646       };
51647     }
51648   }
51649 }
51650
51651
51652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51653   unsigned int jresult ;
51654   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51655   bool result;
51656
51657   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51658   {
51659     try {
51660       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);
51661     } catch (std::out_of_range& e) {
51662       {
51663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51664       };
51665     } catch (std::exception& e) {
51666       {
51667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51668       };
51669     } catch (...) {
51670       {
51671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51672       };
51673     }
51674   }
51675   jresult = result;
51676   return jresult;
51677 }
51678
51679
51680 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51681   unsigned long jresult ;
51682   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51683   std::size_t result;
51684
51685   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51686   {
51687     try {
51688       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);
51689     } catch (std::out_of_range& e) {
51690       {
51691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51692       };
51693     } catch (std::exception& e) {
51694       {
51695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51696       };
51697     } catch (...) {
51698       {
51699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51700       };
51701     }
51702   }
51703   jresult = (unsigned long)result;
51704   return jresult;
51705 }
51706
51707
51708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51709   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51710   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51711
51712   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51713   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51714   {
51715     try {
51716       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51717     } catch (std::out_of_range& e) {
51718       {
51719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51720       };
51721     } catch (std::exception& e) {
51722       {
51723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51724       };
51725     } catch (...) {
51726       {
51727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51728       };
51729     }
51730   }
51731 }
51732
51733
51734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51735   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51736   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51737
51738   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51739   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51740   {
51741     try {
51742       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51743     } catch (std::out_of_range& e) {
51744       {
51745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51746       };
51747     } catch (std::exception& e) {
51748       {
51749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51750       };
51751     } catch (...) {
51752       {
51753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51754       };
51755     }
51756   }
51757 }
51758
51759
51760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51761   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51762   Dali::Actor arg2 ;
51763   Dali::PinchGesture *arg3 = 0 ;
51764   Dali::Actor *argp2 ;
51765
51766   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51767   argp2 = (Dali::Actor *)jarg2;
51768   if (!argp2) {
51769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51770     return ;
51771   }
51772   arg2 = *argp2;
51773   arg3 = (Dali::PinchGesture *)jarg3;
51774   if (!arg3) {
51775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51776     return ;
51777   }
51778   {
51779     try {
51780       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51781     } catch (std::out_of_range& e) {
51782       {
51783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51784       };
51785     } catch (std::exception& e) {
51786       {
51787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51788       };
51789     } catch (...) {
51790       {
51791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51792       };
51793     }
51794   }
51795 }
51796
51797
51798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51799   void * jresult ;
51800   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51801
51802   {
51803     try {
51804       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
51805     } catch (std::out_of_range& e) {
51806       {
51807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51808       };
51809     } catch (std::exception& e) {
51810       {
51811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51812       };
51813     } catch (...) {
51814       {
51815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51816       };
51817     }
51818   }
51819   jresult = (void *)result;
51820   return jresult;
51821 }
51822
51823
51824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
51825   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51826
51827   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51828   {
51829     try {
51830       delete arg1;
51831     } catch (std::out_of_range& e) {
51832       {
51833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51834       };
51835     } catch (std::exception& e) {
51836       {
51837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51838       };
51839     } catch (...) {
51840       {
51841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51842       };
51843     }
51844   }
51845 }
51846
51847
51848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
51849   unsigned int jresult ;
51850   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51851   bool result;
51852
51853   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51854   {
51855     try {
51856       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);
51857     } catch (std::out_of_range& e) {
51858       {
51859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51860       };
51861     } catch (std::exception& e) {
51862       {
51863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51864       };
51865     } catch (...) {
51866       {
51867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51868       };
51869     }
51870   }
51871   jresult = result;
51872   return jresult;
51873 }
51874
51875
51876 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51877   unsigned long jresult ;
51878   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51879   std::size_t result;
51880
51881   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51882   {
51883     try {
51884       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);
51885     } catch (std::out_of_range& e) {
51886       {
51887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51888       };
51889     } catch (std::exception& e) {
51890       {
51891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51892       };
51893     } catch (...) {
51894       {
51895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51896       };
51897     }
51898   }
51899   jresult = (unsigned long)result;
51900   return jresult;
51901 }
51902
51903
51904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51905   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51906   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51907
51908   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51909   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51910   {
51911     try {
51912       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51913     } catch (std::out_of_range& e) {
51914       {
51915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51916       };
51917     } catch (std::exception& e) {
51918       {
51919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51920       };
51921     } catch (...) {
51922       {
51923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51924       };
51925     }
51926   }
51927 }
51928
51929
51930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51931   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51932   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
51933
51934   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51935   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
51936   {
51937     try {
51938       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51939     } catch (std::out_of_range& e) {
51940       {
51941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51942       };
51943     } catch (std::exception& e) {
51944       {
51945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51946       };
51947     } catch (...) {
51948       {
51949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51950       };
51951     }
51952   }
51953 }
51954
51955
51956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51957   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
51958   Dali::Actor arg2 ;
51959   Dali::TapGesture *arg3 = 0 ;
51960   Dali::Actor *argp2 ;
51961
51962   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
51963   argp2 = (Dali::Actor *)jarg2;
51964   if (!argp2) {
51965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51966     return ;
51967   }
51968   arg2 = *argp2;
51969   arg3 = (Dali::TapGesture *)jarg3;
51970   if (!arg3) {
51971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
51972     return ;
51973   }
51974   {
51975     try {
51976       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
51977     } catch (std::out_of_range& e) {
51978       {
51979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51980       };
51981     } catch (std::exception& e) {
51982       {
51983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51984       };
51985     } catch (...) {
51986       {
51987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51988       };
51989     }
51990   }
51991 }
51992
51993
51994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
51995   void * jresult ;
51996   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
51997
51998   {
51999     try {
52000       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52001     } catch (std::out_of_range& e) {
52002       {
52003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52004       };
52005     } catch (std::exception& e) {
52006       {
52007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52008       };
52009     } catch (...) {
52010       {
52011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52012       };
52013     }
52014   }
52015   jresult = (void *)result;
52016   return jresult;
52017 }
52018
52019
52020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52021   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52022
52023   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52024   {
52025     try {
52026       delete arg1;
52027     } catch (std::out_of_range& e) {
52028       {
52029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52030       };
52031     } catch (std::exception& e) {
52032       {
52033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52034       };
52035     } catch (...) {
52036       {
52037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52038       };
52039     }
52040   }
52041 }
52042
52043
52044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52045   unsigned int jresult ;
52046   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52047   bool result;
52048
52049   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52050   {
52051     try {
52052       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52053     } catch (std::out_of_range& e) {
52054       {
52055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52056       };
52057     } catch (std::exception& e) {
52058       {
52059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52060       };
52061     } catch (...) {
52062       {
52063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52064       };
52065     }
52066   }
52067   jresult = result;
52068   return jresult;
52069 }
52070
52071
52072 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52073   unsigned long jresult ;
52074   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52075   std::size_t result;
52076
52077   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52078   {
52079     try {
52080       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52081     } catch (std::out_of_range& e) {
52082       {
52083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52084       };
52085     } catch (std::exception& e) {
52086       {
52087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52088       };
52089     } catch (...) {
52090       {
52091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52092       };
52093     }
52094   }
52095   jresult = (unsigned long)result;
52096   return jresult;
52097 }
52098
52099
52100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52101   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52102   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52103
52104   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52105   arg2 = (void (*)(Dali::Animation &))jarg2;
52106   {
52107     try {
52108       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52109     } catch (std::out_of_range& e) {
52110       {
52111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52112       };
52113     } catch (std::exception& e) {
52114       {
52115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52116       };
52117     } catch (...) {
52118       {
52119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52120       };
52121     }
52122   }
52123 }
52124
52125
52126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52127   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52128   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52129
52130   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52131   arg2 = (void (*)(Dali::Animation &))jarg2;
52132   {
52133     try {
52134       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52135     } catch (std::out_of_range& e) {
52136       {
52137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52138       };
52139     } catch (std::exception& e) {
52140       {
52141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52142       };
52143     } catch (...) {
52144       {
52145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52146       };
52147     }
52148   }
52149 }
52150
52151
52152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52153   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52154   Dali::Animation *arg2 = 0 ;
52155
52156   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52157   arg2 = (Dali::Animation *)jarg2;
52158   if (!arg2) {
52159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52160     return ;
52161   }
52162   {
52163     try {
52164       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52165     } catch (std::out_of_range& e) {
52166       {
52167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52168       };
52169     } catch (std::exception& e) {
52170       {
52171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52172       };
52173     } catch (...) {
52174       {
52175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52176       };
52177     }
52178   }
52179 }
52180
52181
52182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52183   void * jresult ;
52184   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52185
52186   {
52187     try {
52188       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52189     } catch (std::out_of_range& e) {
52190       {
52191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52192       };
52193     } catch (std::exception& e) {
52194       {
52195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52196       };
52197     } catch (...) {
52198       {
52199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52200       };
52201     }
52202   }
52203   jresult = (void *)result;
52204   return jresult;
52205 }
52206
52207
52208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52209   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52210
52211   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52212   {
52213     try {
52214       delete arg1;
52215     } catch (std::out_of_range& e) {
52216       {
52217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52218       };
52219     } catch (std::exception& e) {
52220       {
52221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52222       };
52223     } catch (...) {
52224       {
52225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52226       };
52227     }
52228   }
52229 }
52230
52231
52232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52233   unsigned int jresult ;
52234   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52235   bool result;
52236
52237   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52238   {
52239     try {
52240       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52241     } catch (std::out_of_range& e) {
52242       {
52243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52244       };
52245     } catch (std::exception& e) {
52246       {
52247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52248       };
52249     } catch (...) {
52250       {
52251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52252       };
52253     }
52254   }
52255   jresult = result;
52256   return jresult;
52257 }
52258
52259
52260 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52261   unsigned long jresult ;
52262   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52263   std::size_t result;
52264
52265   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52266   {
52267     try {
52268       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52269     } catch (std::out_of_range& e) {
52270       {
52271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52272       };
52273     } catch (std::exception& e) {
52274       {
52275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52276       };
52277     } catch (...) {
52278       {
52279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52280       };
52281     }
52282   }
52283   jresult = (unsigned long)result;
52284   return jresult;
52285 }
52286
52287
52288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52289   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52290   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52291
52292   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52293   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52294   {
52295     try {
52296       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52297     } catch (std::out_of_range& e) {
52298       {
52299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52300       };
52301     } catch (std::exception& e) {
52302       {
52303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52304       };
52305     } catch (...) {
52306       {
52307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52308       };
52309     }
52310   }
52311 }
52312
52313
52314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52315   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52316   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52317
52318   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52319   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52320   {
52321     try {
52322       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52323     } catch (std::out_of_range& e) {
52324       {
52325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52326       };
52327     } catch (std::exception& e) {
52328       {
52329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52330       };
52331     } catch (...) {
52332       {
52333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52334       };
52335     }
52336   }
52337 }
52338
52339
52340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52341   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52342   Dali::ResourceImage arg2 ;
52343   Dali::ResourceImage *argp2 ;
52344
52345   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52346   argp2 = (Dali::ResourceImage *)jarg2;
52347   if (!argp2) {
52348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52349     return ;
52350   }
52351   arg2 = *argp2;
52352   {
52353     try {
52354       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52355     } catch (std::out_of_range& e) {
52356       {
52357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52358       };
52359     } catch (std::exception& e) {
52360       {
52361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52362       };
52363     } catch (...) {
52364       {
52365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52366       };
52367     }
52368   }
52369 }
52370
52371
52372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52373   void * jresult ;
52374   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52375
52376   {
52377     try {
52378       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52379     } catch (std::out_of_range& e) {
52380       {
52381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52382       };
52383     } catch (std::exception& e) {
52384       {
52385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52386       };
52387     } catch (...) {
52388       {
52389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52390       };
52391     }
52392   }
52393   jresult = (void *)result;
52394   return jresult;
52395 }
52396
52397
52398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52399   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52400
52401   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52402   {
52403     try {
52404       delete arg1;
52405     } catch (std::out_of_range& e) {
52406       {
52407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52408       };
52409     } catch (std::exception& e) {
52410       {
52411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52412       };
52413     } catch (...) {
52414       {
52415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52416       };
52417     }
52418   }
52419 }
52420
52421
52422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52423   void * jresult ;
52424   Dali::Timer *result = 0 ;
52425
52426   {
52427     try {
52428       result = (Dali::Timer *)new Dali::Timer();
52429     } catch (std::out_of_range& e) {
52430       {
52431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52432       };
52433     } catch (std::exception& e) {
52434       {
52435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52436       };
52437     } catch (...) {
52438       {
52439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52440       };
52441     }
52442   }
52443   jresult = (void *)result;
52444   return jresult;
52445 }
52446
52447
52448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52449   void * jresult ;
52450   unsigned int arg1 ;
52451   Dali::Timer result;
52452
52453   arg1 = (unsigned int)jarg1;
52454   {
52455     try {
52456       result = Dali::Timer::New(arg1);
52457     } catch (std::out_of_range& e) {
52458       {
52459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52460       };
52461     } catch (std::exception& e) {
52462       {
52463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52464       };
52465     } catch (...) {
52466       {
52467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52468       };
52469     }
52470   }
52471   jresult = new Dali::Timer((const Dali::Timer &)result);
52472   return jresult;
52473 }
52474
52475
52476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52477   void * jresult ;
52478   Dali::Timer *arg1 = 0 ;
52479   Dali::Timer *result = 0 ;
52480
52481   arg1 = (Dali::Timer *)jarg1;
52482   if (!arg1) {
52483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52484     return 0;
52485   }
52486   {
52487     try {
52488       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52489     } catch (std::out_of_range& e) {
52490       {
52491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52492       };
52493     } catch (std::exception& e) {
52494       {
52495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52496       };
52497     } catch (...) {
52498       {
52499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52500       };
52501     }
52502   }
52503   jresult = (void *)result;
52504   return jresult;
52505 }
52506
52507
52508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52509   void * jresult ;
52510   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52511   Dali::Timer *arg2 = 0 ;
52512   Dali::Timer *result = 0 ;
52513
52514   arg1 = (Dali::Timer *)jarg1;
52515   arg2 = (Dali::Timer *)jarg2;
52516   if (!arg2) {
52517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52518     return 0;
52519   }
52520   {
52521     try {
52522       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52523     } catch (std::out_of_range& e) {
52524       {
52525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52526       };
52527     } catch (std::exception& e) {
52528       {
52529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52530       };
52531     } catch (...) {
52532       {
52533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52534       };
52535     }
52536   }
52537   jresult = (void *)result;
52538   return jresult;
52539 }
52540
52541
52542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52543   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52544
52545   arg1 = (Dali::Timer *)jarg1;
52546   {
52547     try {
52548       delete arg1;
52549     } catch (std::out_of_range& e) {
52550       {
52551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52552       };
52553     } catch (std::exception& e) {
52554       {
52555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52556       };
52557     } catch (...) {
52558       {
52559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52560       };
52561     }
52562   }
52563 }
52564
52565
52566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52567   void * jresult ;
52568   Dali::BaseHandle arg1 ;
52569   Dali::BaseHandle *argp1 ;
52570   Dali::Timer result;
52571
52572   argp1 = (Dali::BaseHandle *)jarg1;
52573   if (!argp1) {
52574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52575     return 0;
52576   }
52577   arg1 = *argp1;
52578   {
52579     try {
52580       result = Dali::Timer::DownCast(arg1);
52581     } catch (std::out_of_range& e) {
52582       {
52583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52584       };
52585     } catch (std::exception& e) {
52586       {
52587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52588       };
52589     } catch (...) {
52590       {
52591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52592       };
52593     }
52594   }
52595   jresult = new Dali::Timer((const Dali::Timer &)result);
52596   return jresult;
52597 }
52598
52599
52600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52601   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52602
52603   arg1 = (Dali::Timer *)jarg1;
52604   {
52605     try {
52606       (arg1)->Start();
52607     } catch (std::out_of_range& e) {
52608       {
52609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52610       };
52611     } catch (std::exception& e) {
52612       {
52613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52614       };
52615     } catch (...) {
52616       {
52617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52618       };
52619     }
52620   }
52621 }
52622
52623
52624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
52625   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52626
52627   arg1 = (Dali::Timer *)jarg1;
52628   {
52629     try {
52630       (arg1)->Stop();
52631     } catch (std::out_of_range& e) {
52632       {
52633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52634       };
52635     } catch (std::exception& e) {
52636       {
52637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52638       };
52639     } catch (...) {
52640       {
52641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52642       };
52643     }
52644   }
52645 }
52646
52647
52648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
52649   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52650   unsigned int arg2 ;
52651
52652   arg1 = (Dali::Timer *)jarg1;
52653   arg2 = (unsigned int)jarg2;
52654   {
52655     try {
52656       (arg1)->SetInterval(arg2);
52657     } catch (std::out_of_range& e) {
52658       {
52659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52660       };
52661     } catch (std::exception& e) {
52662       {
52663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52664       };
52665     } catch (...) {
52666       {
52667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52668       };
52669     }
52670   }
52671 }
52672
52673
52674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
52675   unsigned int jresult ;
52676   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52677   unsigned int result;
52678
52679   arg1 = (Dali::Timer *)jarg1;
52680   {
52681     try {
52682       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
52683     } catch (std::out_of_range& e) {
52684       {
52685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52686       };
52687     } catch (std::exception& e) {
52688       {
52689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52690       };
52691     } catch (...) {
52692       {
52693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52694       };
52695     }
52696   }
52697   jresult = result;
52698   return jresult;
52699 }
52700
52701
52702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
52703   unsigned int jresult ;
52704   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52705   bool result;
52706
52707   arg1 = (Dali::Timer *)jarg1;
52708   {
52709     try {
52710       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
52711     } catch (std::out_of_range& e) {
52712       {
52713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52714       };
52715     } catch (std::exception& e) {
52716       {
52717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52718       };
52719     } catch (...) {
52720       {
52721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52722       };
52723     }
52724   }
52725   jresult = result;
52726   return jresult;
52727 }
52728
52729
52730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
52731   void * jresult ;
52732   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52733   Dali::Timer::TimerSignalType *result = 0 ;
52734
52735   arg1 = (Dali::Timer *)jarg1;
52736   {
52737     try {
52738       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
52739     } catch (std::out_of_range& e) {
52740       {
52741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52742       };
52743     } catch (std::exception& e) {
52744       {
52745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52746       };
52747     } catch (...) {
52748       {
52749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52750       };
52751     }
52752   }
52753   jresult = (void *)result;
52754   return jresult;
52755 }
52756
52757
52758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
52759   void * jresult ;
52760   Dali::DragAndDropDetector *result = 0 ;
52761
52762   {
52763     try {
52764       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
52765     } catch (std::out_of_range& e) {
52766       {
52767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52768       };
52769     } catch (std::exception& e) {
52770       {
52771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52772       };
52773     } catch (...) {
52774       {
52775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52776       };
52777     }
52778   }
52779   jresult = (void *)result;
52780   return jresult;
52781 }
52782
52783
52784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
52785   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52786
52787   arg1 = (Dali::DragAndDropDetector *)jarg1;
52788   {
52789     try {
52790       delete arg1;
52791     } catch (std::out_of_range& e) {
52792       {
52793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52794       };
52795     } catch (std::exception& e) {
52796       {
52797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52798       };
52799     } catch (...) {
52800       {
52801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52802       };
52803     }
52804   }
52805 }
52806
52807
52808 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
52809   char * jresult ;
52810   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52811   std::string *result = 0 ;
52812
52813   arg1 = (Dali::DragAndDropDetector *)jarg1;
52814   {
52815     try {
52816       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
52817     } catch (std::out_of_range& e) {
52818       {
52819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52820       };
52821     } catch (std::exception& e) {
52822       {
52823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52824       };
52825     } catch (...) {
52826       {
52827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52828       };
52829     }
52830   }
52831   jresult = SWIG_csharp_string_callback(result->c_str());
52832   return jresult;
52833 }
52834
52835
52836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
52837   void * jresult ;
52838   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52839   Dali::Vector2 result;
52840
52841   arg1 = (Dali::DragAndDropDetector *)jarg1;
52842   {
52843     try {
52844       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
52845     } catch (std::out_of_range& e) {
52846       {
52847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52848       };
52849     } catch (std::exception& e) {
52850       {
52851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52852       };
52853     } catch (...) {
52854       {
52855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52856       };
52857     }
52858   }
52859   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
52860   return jresult;
52861 }
52862
52863
52864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
52865   void * jresult ;
52866   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52867   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52868
52869   arg1 = (Dali::DragAndDropDetector *)jarg1;
52870   {
52871     try {
52872       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
52873     } catch (std::out_of_range& e) {
52874       {
52875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52876       };
52877     } catch (std::exception& e) {
52878       {
52879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52880       };
52881     } catch (...) {
52882       {
52883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52884       };
52885     }
52886   }
52887   jresult = (void *)result;
52888   return jresult;
52889 }
52890
52891
52892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
52893   void * jresult ;
52894   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52895   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52896
52897   arg1 = (Dali::DragAndDropDetector *)jarg1;
52898   {
52899     try {
52900       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
52901     } catch (std::out_of_range& e) {
52902       {
52903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52904       };
52905     } catch (std::exception& e) {
52906       {
52907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52908       };
52909     } catch (...) {
52910       {
52911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52912       };
52913     }
52914   }
52915   jresult = (void *)result;
52916   return jresult;
52917 }
52918
52919
52920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
52921   void * jresult ;
52922   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52923   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52924
52925   arg1 = (Dali::DragAndDropDetector *)jarg1;
52926   {
52927     try {
52928       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
52929     } catch (std::out_of_range& e) {
52930       {
52931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52932       };
52933     } catch (std::exception& e) {
52934       {
52935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52936       };
52937     } catch (...) {
52938       {
52939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52940       };
52941     }
52942   }
52943   jresult = (void *)result;
52944   return jresult;
52945 }
52946
52947
52948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
52949   void * jresult ;
52950   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52951   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
52952
52953   arg1 = (Dali::DragAndDropDetector *)jarg1;
52954   {
52955     try {
52956       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
52957     } catch (std::out_of_range& e) {
52958       {
52959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52960       };
52961     } catch (std::exception& e) {
52962       {
52963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52964       };
52965     } catch (...) {
52966       {
52967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52968       };
52969     }
52970   }
52971   jresult = (void *)result;
52972   return jresult;
52973 }
52974
52975
52976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
52977   void * jresult ;
52978   Dali::ApplicationExtensions *result = 0 ;
52979
52980   {
52981     try {
52982       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
52983     } catch (std::out_of_range& e) {
52984       {
52985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52986       };
52987     } catch (std::exception& e) {
52988       {
52989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52990       };
52991     } catch (...) {
52992       {
52993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52994       };
52995     }
52996   }
52997   jresult = (void *)result;
52998   return jresult;
52999 }
53000
53001
53002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53003   void * jresult ;
53004   Dali::Application *arg1 = (Dali::Application *) 0 ;
53005   Dali::ApplicationExtensions *result = 0 ;
53006
53007   arg1 = (Dali::Application *)jarg1;
53008   {
53009     try {
53010       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53011     } catch (std::out_of_range& e) {
53012       {
53013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53014       };
53015     } catch (std::exception& e) {
53016       {
53017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53018       };
53019     } catch (...) {
53020       {
53021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53022       };
53023     }
53024   }
53025   jresult = (void *)result;
53026   return jresult;
53027 }
53028
53029
53030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53031   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53032
53033   arg1 = (Dali::ApplicationExtensions *)jarg1;
53034   {
53035     try {
53036       delete arg1;
53037     } catch (std::out_of_range& e) {
53038       {
53039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53040       };
53041     } catch (std::exception& e) {
53042       {
53043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53044       };
53045     } catch (...) {
53046       {
53047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53048       };
53049     }
53050   }
53051 }
53052
53053
53054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53055   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53056
53057   arg1 = (Dali::ApplicationExtensions *)jarg1;
53058   {
53059     try {
53060       (arg1)->Init();
53061     } catch (std::out_of_range& e) {
53062       {
53063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53064       };
53065     } catch (std::exception& e) {
53066       {
53067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53068       };
53069     } catch (...) {
53070       {
53071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53072       };
53073     }
53074   }
53075 }
53076
53077
53078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53079   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53080
53081   arg1 = (Dali::ApplicationExtensions *)jarg1;
53082   {
53083     try {
53084       (arg1)->Terminate();
53085     } catch (std::out_of_range& e) {
53086       {
53087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53088       };
53089     } catch (std::exception& e) {
53090       {
53091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53092       };
53093     } catch (...) {
53094       {
53095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53096       };
53097     }
53098   }
53099 }
53100
53101
53102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53103   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53104
53105   arg1 = (Dali::ApplicationExtensions *)jarg1;
53106   {
53107     try {
53108       (arg1)->Pause();
53109     } catch (std::out_of_range& e) {
53110       {
53111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53112       };
53113     } catch (std::exception& e) {
53114       {
53115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53116       };
53117     } catch (...) {
53118       {
53119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53120       };
53121     }
53122   }
53123 }
53124
53125
53126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53127   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53128
53129   arg1 = (Dali::ApplicationExtensions *)jarg1;
53130   {
53131     try {
53132       (arg1)->Resume();
53133     } catch (std::out_of_range& e) {
53134       {
53135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53136       };
53137     } catch (std::exception& e) {
53138       {
53139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53140       };
53141     } catch (...) {
53142       {
53143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53144       };
53145     }
53146   }
53147 }
53148
53149
53150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53151   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53152
53153   arg1 = (Dali::ApplicationExtensions *)jarg1;
53154   {
53155     try {
53156       (arg1)->LanguageChange();
53157     } catch (std::out_of_range& e) {
53158       {
53159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53160       };
53161     } catch (std::exception& e) {
53162       {
53163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53164       };
53165     } catch (...) {
53166       {
53167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53168       };
53169     }
53170   }
53171 }
53172
53173
53174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53175   void * jresult ;
53176   Dali::PositionSize arg1 ;
53177   std::string *arg2 = 0 ;
53178   bool arg3 ;
53179   Dali::PositionSize *argp1 ;
53180   Dali::Window result;
53181
53182   argp1 = (Dali::PositionSize *)jarg1;
53183   if (!argp1) {
53184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53185     return 0;
53186   }
53187   arg1 = *argp1;
53188   if (!jarg2) {
53189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53190     return 0;
53191   }
53192   std::string arg2_str(jarg2);
53193   arg2 = &arg2_str;
53194   arg3 = jarg3 ? true : false;
53195   {
53196     try {
53197       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53198     } catch (std::out_of_range& e) {
53199       {
53200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53201       };
53202     } catch (std::exception& e) {
53203       {
53204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53205       };
53206     } catch (...) {
53207       {
53208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53209       };
53210     }
53211   }
53212   jresult = new Dali::Window((const Dali::Window &)result);
53213
53214   //argout typemap for const std::string&
53215
53216   return jresult;
53217 }
53218
53219
53220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53221   void * jresult ;
53222   Dali::PositionSize arg1 ;
53223   std::string *arg2 = 0 ;
53224   Dali::PositionSize *argp1 ;
53225   Dali::Window result;
53226
53227   argp1 = (Dali::PositionSize *)jarg1;
53228   if (!argp1) {
53229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53230     return 0;
53231   }
53232   arg1 = *argp1;
53233   if (!jarg2) {
53234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53235     return 0;
53236   }
53237   std::string arg2_str(jarg2);
53238   arg2 = &arg2_str;
53239   {
53240     try {
53241       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53242     } catch (std::out_of_range& e) {
53243       {
53244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53245       };
53246     } catch (std::exception& e) {
53247       {
53248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53249       };
53250     } catch (...) {
53251       {
53252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53253       };
53254     }
53255   }
53256   jresult = new Dali::Window((const Dali::Window &)result);
53257
53258   //argout typemap for const std::string&
53259
53260   return jresult;
53261 }
53262
53263
53264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53265   void * jresult ;
53266   Dali::PositionSize arg1 ;
53267   std::string *arg2 = 0 ;
53268   std::string *arg3 = 0 ;
53269   bool arg4 ;
53270   Dali::PositionSize *argp1 ;
53271   Dali::Window result;
53272
53273   argp1 = (Dali::PositionSize *)jarg1;
53274   if (!argp1) {
53275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53276     return 0;
53277   }
53278   arg1 = *argp1;
53279   if (!jarg2) {
53280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53281     return 0;
53282   }
53283   std::string arg2_str(jarg2);
53284   arg2 = &arg2_str;
53285   if (!jarg3) {
53286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53287     return 0;
53288   }
53289   std::string arg3_str(jarg3);
53290   arg3 = &arg3_str;
53291   arg4 = jarg4 ? true : false;
53292   {
53293     try {
53294       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
53295     } catch (std::out_of_range& e) {
53296       {
53297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53298       };
53299     } catch (std::exception& e) {
53300       {
53301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53302       };
53303     } catch (...) {
53304       {
53305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53306       };
53307     }
53308   }
53309   jresult = new Dali::Window((const Dali::Window &)result);
53310
53311   //argout typemap for const std::string&
53312
53313
53314   //argout typemap for const std::string&
53315
53316   return jresult;
53317 }
53318
53319
53320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53321   void * jresult ;
53322   Dali::PositionSize arg1 ;
53323   std::string *arg2 = 0 ;
53324   std::string *arg3 = 0 ;
53325   Dali::PositionSize *argp1 ;
53326   Dali::Window result;
53327
53328   argp1 = (Dali::PositionSize *)jarg1;
53329   if (!argp1) {
53330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53331     return 0;
53332   }
53333   arg1 = *argp1;
53334   if (!jarg2) {
53335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53336     return 0;
53337   }
53338   std::string arg2_str(jarg2);
53339   arg2 = &arg2_str;
53340   if (!jarg3) {
53341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53342     return 0;
53343   }
53344   std::string arg3_str(jarg3);
53345   arg3 = &arg3_str;
53346   {
53347     try {
53348       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53349     } catch (std::out_of_range& e) {
53350       {
53351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53352       };
53353     } catch (std::exception& e) {
53354       {
53355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53356       };
53357     } catch (...) {
53358       {
53359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53360       };
53361     }
53362   }
53363   jresult = new Dali::Window((const Dali::Window &)result);
53364
53365   //argout typemap for const std::string&
53366
53367
53368   //argout typemap for const std::string&
53369
53370   return jresult;
53371 }
53372
53373
53374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53375   void * jresult ;
53376   Dali::Window *result = 0 ;
53377
53378   {
53379     try {
53380       result = (Dali::Window *)new Dali::Window();
53381     } catch (std::out_of_range& e) {
53382       {
53383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53384       };
53385     } catch (std::exception& e) {
53386       {
53387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53388       };
53389     } catch (...) {
53390       {
53391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53392       };
53393     }
53394   }
53395   jresult = (void *)result;
53396   return jresult;
53397 }
53398
53399
53400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53401   Dali::Window *arg1 = (Dali::Window *) 0 ;
53402
53403   arg1 = (Dali::Window *)jarg1;
53404   {
53405     try {
53406       delete arg1;
53407     } catch (std::out_of_range& e) {
53408       {
53409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53410       };
53411     } catch (std::exception& e) {
53412       {
53413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53414       };
53415     } catch (...) {
53416       {
53417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53418       };
53419     }
53420   }
53421 }
53422
53423
53424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53425   void * jresult ;
53426   Dali::Window *arg1 = 0 ;
53427   Dali::Window *result = 0 ;
53428
53429   arg1 = (Dali::Window *)jarg1;
53430   if (!arg1) {
53431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53432     return 0;
53433   }
53434   {
53435     try {
53436       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53437     } catch (std::out_of_range& e) {
53438       {
53439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53440       };
53441     } catch (std::exception& e) {
53442       {
53443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53444       };
53445     } catch (...) {
53446       {
53447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53448       };
53449     }
53450   }
53451   jresult = (void *)result;
53452   return jresult;
53453 }
53454
53455
53456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53457   void * jresult ;
53458   Dali::Window *arg1 = (Dali::Window *) 0 ;
53459   Dali::Window *arg2 = 0 ;
53460   Dali::Window *result = 0 ;
53461
53462   arg1 = (Dali::Window *)jarg1;
53463   arg2 = (Dali::Window *)jarg2;
53464   if (!arg2) {
53465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53466     return 0;
53467   }
53468   {
53469     try {
53470       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53471     } catch (std::out_of_range& e) {
53472       {
53473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53474       };
53475     } catch (std::exception& e) {
53476       {
53477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53478       };
53479     } catch (...) {
53480       {
53481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53482       };
53483     }
53484   }
53485   jresult = (void *)result;
53486   return jresult;
53487 }
53488
53489
53490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53491   Dali::Window *arg1 = (Dali::Window *) 0 ;
53492   Dali::Window::IndicatorVisibleMode arg2 ;
53493
53494   arg1 = (Dali::Window *)jarg1;
53495   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53496   {
53497     try {
53498       (arg1)->ShowIndicator(arg2);
53499     } catch (std::out_of_range& e) {
53500       {
53501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53502       };
53503     } catch (std::exception& e) {
53504       {
53505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53506       };
53507     } catch (...) {
53508       {
53509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53510       };
53511     }
53512   }
53513 }
53514
53515
53516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53517   Dali::Window *arg1 = (Dali::Window *) 0 ;
53518   Dali::Window::IndicatorBgOpacity arg2 ;
53519
53520   arg1 = (Dali::Window *)jarg1;
53521   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53522   {
53523     try {
53524       (arg1)->SetIndicatorBgOpacity(arg2);
53525     } catch (std::out_of_range& e) {
53526       {
53527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53528       };
53529     } catch (std::exception& e) {
53530       {
53531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53532       };
53533     } catch (...) {
53534       {
53535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53536       };
53537     }
53538   }
53539 }
53540
53541
53542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53543   Dali::Window *arg1 = (Dali::Window *) 0 ;
53544   Dali::Window::WindowOrientation arg2 ;
53545
53546   arg1 = (Dali::Window *)jarg1;
53547   arg2 = (Dali::Window::WindowOrientation)jarg2;
53548   {
53549     try {
53550       (arg1)->RotateIndicator(arg2);
53551     } catch (std::out_of_range& e) {
53552       {
53553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53554       };
53555     } catch (std::exception& e) {
53556       {
53557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53558       };
53559     } catch (...) {
53560       {
53561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53562       };
53563     }
53564   }
53565 }
53566
53567
53568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53569   Dali::Window *arg1 = (Dali::Window *) 0 ;
53570   std::string arg2 ;
53571   std::string arg3 ;
53572
53573   arg1 = (Dali::Window *)jarg1;
53574   if (!jarg2) {
53575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53576     return ;
53577   }
53578   (&arg2)->assign(jarg2);
53579   if (!jarg3) {
53580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53581     return ;
53582   }
53583   (&arg3)->assign(jarg3);
53584   {
53585     try {
53586       (arg1)->SetClass(arg2,arg3);
53587     } catch (std::out_of_range& e) {
53588       {
53589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53590       };
53591     } catch (std::exception& e) {
53592       {
53593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53594       };
53595     } catch (...) {
53596       {
53597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53598       };
53599     }
53600   }
53601 }
53602
53603
53604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53605   Dali::Window *arg1 = (Dali::Window *) 0 ;
53606
53607   arg1 = (Dali::Window *)jarg1;
53608   {
53609     try {
53610       (arg1)->Raise();
53611     } catch (std::out_of_range& e) {
53612       {
53613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53614       };
53615     } catch (std::exception& e) {
53616       {
53617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53618       };
53619     } catch (...) {
53620       {
53621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53622       };
53623     }
53624   }
53625 }
53626
53627
53628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
53629   Dali::Window *arg1 = (Dali::Window *) 0 ;
53630
53631   arg1 = (Dali::Window *)jarg1;
53632   {
53633     try {
53634       (arg1)->Lower();
53635     } catch (std::out_of_range& e) {
53636       {
53637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53638       };
53639     } catch (std::exception& e) {
53640       {
53641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53642       };
53643     } catch (...) {
53644       {
53645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53646       };
53647     }
53648   }
53649 }
53650
53651
53652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
53653   Dali::Window *arg1 = (Dali::Window *) 0 ;
53654
53655   arg1 = (Dali::Window *)jarg1;
53656   {
53657     try {
53658       (arg1)->Activate();
53659     } catch (std::out_of_range& e) {
53660       {
53661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53662       };
53663     } catch (std::exception& e) {
53664       {
53665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53666       };
53667     } catch (...) {
53668       {
53669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53670       };
53671     }
53672   }
53673 }
53674
53675
53676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
53677   Dali::Window *arg1 = (Dali::Window *) 0 ;
53678   Dali::Window::WindowOrientation arg2 ;
53679
53680   arg1 = (Dali::Window *)jarg1;
53681   arg2 = (Dali::Window::WindowOrientation)jarg2;
53682   {
53683     try {
53684       (arg1)->AddAvailableOrientation(arg2);
53685     } catch (std::out_of_range& e) {
53686       {
53687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53688       };
53689     } catch (std::exception& e) {
53690       {
53691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53692       };
53693     } catch (...) {
53694       {
53695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53696       };
53697     }
53698   }
53699 }
53700
53701
53702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
53703   Dali::Window *arg1 = (Dali::Window *) 0 ;
53704   Dali::Window::WindowOrientation arg2 ;
53705
53706   arg1 = (Dali::Window *)jarg1;
53707   arg2 = (Dali::Window::WindowOrientation)jarg2;
53708   {
53709     try {
53710       (arg1)->RemoveAvailableOrientation(arg2);
53711     } catch (std::out_of_range& e) {
53712       {
53713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53714       };
53715     } catch (std::exception& e) {
53716       {
53717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53718       };
53719     } catch (...) {
53720       {
53721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53722       };
53723     }
53724   }
53725 }
53726
53727
53728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
53729   Dali::Window *arg1 = (Dali::Window *) 0 ;
53730   Dali::Window::WindowOrientation arg2 ;
53731
53732   arg1 = (Dali::Window *)jarg1;
53733   arg2 = (Dali::Window::WindowOrientation)jarg2;
53734   {
53735     try {
53736       (arg1)->SetPreferredOrientation(arg2);
53737     } catch (std::out_of_range& e) {
53738       {
53739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53740       };
53741     } catch (std::exception& e) {
53742       {
53743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53744       };
53745     } catch (...) {
53746       {
53747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53748       };
53749     }
53750   }
53751 }
53752
53753
53754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
53755   int jresult ;
53756   Dali::Window *arg1 = (Dali::Window *) 0 ;
53757   Dali::Window::WindowOrientation result;
53758
53759   arg1 = (Dali::Window *)jarg1;
53760   {
53761     try {
53762       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
53763     } catch (std::out_of_range& e) {
53764       {
53765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53766       };
53767     } catch (std::exception& e) {
53768       {
53769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53770       };
53771     } catch (...) {
53772       {
53773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53774       };
53775     }
53776   }
53777   jresult = (int)result;
53778   return jresult;
53779 }
53780
53781
53782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
53783   void * jresult ;
53784   Dali::Window *arg1 = (Dali::Window *) 0 ;
53785   Dali::DragAndDropDetector result;
53786
53787   arg1 = (Dali::Window *)jarg1;
53788   {
53789     try {
53790       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
53791     } catch (std::out_of_range& e) {
53792       {
53793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53794       };
53795     } catch (std::exception& e) {
53796       {
53797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53798       };
53799     } catch (...) {
53800       {
53801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53802       };
53803     }
53804   }
53805   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
53806   return jresult;
53807 }
53808
53809
53810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
53811   void * jresult ;
53812   Dali::Window *arg1 = (Dali::Window *) 0 ;
53813   Dali::Any result;
53814
53815   arg1 = (Dali::Window *)jarg1;
53816   {
53817     try {
53818       result = ((Dali::Window const *)arg1)->GetNativeHandle();
53819     } catch (std::out_of_range& e) {
53820       {
53821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53822       };
53823     } catch (std::exception& e) {
53824       {
53825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53826       };
53827     } catch (...) {
53828       {
53829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53830       };
53831     }
53832   }
53833   jresult = new Dali::Any((const Dali::Any &)result);
53834   return jresult;
53835 }
53836
53837
53838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_IndicatorVisibilityChangedSignal(void * jarg1) {
53839   void * jresult ;
53840   Dali::Window *arg1 = (Dali::Window *) 0 ;
53841   Dali::Window::IndicatorSignalType *result = 0 ;
53842
53843   arg1 = (Dali::Window *)jarg1;
53844   {
53845     try {
53846       result = (Dali::Window::IndicatorSignalType *) &(arg1)->IndicatorVisibilityChangedSignal();
53847     } catch (std::out_of_range& e) {
53848       {
53849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53850       };
53851     } catch (std::exception& e) {
53852       {
53853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53854       };
53855     } catch (...) {
53856       {
53857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53858       };
53859     }
53860   }
53861   jresult = (void *)result;
53862   return jresult;
53863 }
53864
53865
53866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
53867   void * jresult ;
53868   Dali::Window arg1 ;
53869   Dali::Window *argp1 ;
53870   Dali::DevelWindow::FocusSignalType *result = 0 ;
53871
53872   argp1 = (Dali::Window *)jarg1;
53873   if (!argp1) {
53874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53875     return 0;
53876   }
53877   arg1 = *argp1;
53878   {
53879     try {
53880       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
53881     } catch (std::out_of_range& e) {
53882       {
53883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53884       };
53885     } catch (std::exception& e) {
53886       {
53887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53888       };
53889     } catch (...) {
53890       {
53891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53892       };
53893     }
53894   }
53895   jresult = (void *)result;
53896   return jresult;
53897 }
53898
53899
53900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
53901   Dali::Window arg1 ;
53902   bool arg2 ;
53903   Dali::Window *argp1 ;
53904
53905   argp1 = (Dali::Window *)jarg1;
53906   if (!argp1) {
53907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53908     return ;
53909   }
53910   arg1 = *argp1;
53911   arg2 = jarg2 ? true : false;
53912   {
53913     try {
53914       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
53915     } catch (std::out_of_range& e) {
53916       {
53917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53918       };
53919     } catch (std::exception& e) {
53920       {
53921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53922       };
53923     } catch (...) {
53924       {
53925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53926       };
53927     }
53928   }
53929 }
53930
53931
53932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
53933   unsigned int jresult ;
53934   Dali::Window arg1 ;
53935   Dali::Window *argp1 ;
53936   bool result;
53937
53938   argp1 = (Dali::Window *)jarg1;
53939   if (!argp1) {
53940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53941     return 0;
53942   }
53943   arg1 = *argp1;
53944   {
53945     try {
53946       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
53947     } catch (std::out_of_range& e) {
53948       {
53949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53950       };
53951     } catch (std::exception& e) {
53952       {
53953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53954       };
53955     } catch (...) {
53956       {
53957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53958       };
53959     }
53960   }
53961   jresult = result;
53962   return jresult;
53963 }
53964
53965
53966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
53967   Dali::Window arg1 ;
53968   Dali::Window *argp1 ;
53969
53970   argp1 = (Dali::Window *)jarg1;
53971   if (!argp1) {
53972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
53973     return ;
53974   }
53975   arg1 = *argp1;
53976   {
53977     try {
53978       Dali::DevelWindow::Show(arg1);
53979     } catch (std::out_of_range& e) {
53980       {
53981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53982       };
53983     } catch (std::exception& e) {
53984       {
53985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53986       };
53987     } catch (...) {
53988       {
53989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53990       };
53991     }
53992   }
53993 }
53994
53995
53996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
53997   Dali::Window arg1 ;
53998   Dali::Window *argp1 ;
53999
54000   argp1 = (Dali::Window *)jarg1;
54001   if (!argp1) {
54002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54003     return ;
54004   }
54005   arg1 = *argp1;
54006   {
54007     try {
54008       Dali::DevelWindow::Hide(arg1);
54009     } catch (std::out_of_range& e) {
54010       {
54011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54012       };
54013     } catch (std::exception& e) {
54014       {
54015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54016       };
54017     } catch (...) {
54018       {
54019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54020       };
54021     }
54022   }
54023 }
54024
54025
54026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54027   unsigned int jresult ;
54028   Dali::Window arg1 ;
54029   Dali::Window *argp1 ;
54030   bool result;
54031
54032   argp1 = (Dali::Window *)jarg1;
54033   if (!argp1) {
54034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54035     return 0;
54036   }
54037   arg1 = *argp1;
54038   {
54039     try {
54040       result = (bool)Dali::DevelWindow::IsVisible(arg1);
54041     } catch (std::out_of_range& e) {
54042       {
54043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54044       };
54045     } catch (std::exception& e) {
54046       {
54047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54048       };
54049     } catch (...) {
54050       {
54051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54052       };
54053     }
54054   }
54055   jresult = result;
54056   return jresult;
54057 }
54058
54059
54060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
54061   void * jresult ;
54062   Dali::Application result;
54063
54064   {
54065     try {
54066       result = Dali::Application::New();
54067     } catch (std::out_of_range& e) {
54068       {
54069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54070       };
54071     } catch (std::exception& e) {
54072       {
54073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54074       };
54075     } catch (...) {
54076       {
54077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54078       };
54079     }
54080   }
54081   jresult = new Dali::Application((const Dali::Application &)result);
54082   return jresult;
54083 }
54084
54085
54086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
54087   void * jresult ;
54088   int *arg1 = (int *) 0 ;
54089   char ***arg2 ;
54090   Dali::Application result;
54091
54092   {
54093     // Todo generate argv data from the C# args
54094     char **array;         // two dimensional array
54095     int numStrings = 1;     // number of strings
54096     int stringLength = 30;      // max string length.
54097     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54098     argV = array;
54099
54100     // allocate the string data
54101     for( int i=0; i < numStrings; i++)
54102     {
54103       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54104     }
54105     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54106
54107     strcpy( array[0], "dali-csharp-app");
54108
54109     arg1 = &argC;
54110     arg2 = &argV;
54111   }
54112   {
54113     try {
54114       result = Dali::Application::New(arg1,arg2);
54115     } catch (std::out_of_range& e) {
54116       {
54117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54118       };
54119     } catch (std::exception& e) {
54120       {
54121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54122       };
54123     } catch (...) {
54124       {
54125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54126       };
54127     }
54128   }
54129   jresult = new Dali::Application((const Dali::Application &)result);
54130   return jresult;
54131 }
54132
54133
54134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
54135   void * jresult ;
54136   int *arg1 = (int *) 0 ;
54137   char ***arg2 ;
54138   std::string *arg3 = 0 ;
54139   Dali::Application result;
54140
54141   {
54142     // Todo generate argv data from the C# args
54143     char **array;         // two dimensional array
54144     int numStrings = 1;     // number of strings
54145     int stringLength = 30;      // max string length.
54146     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54147     argV = array;
54148
54149     // allocate the string data
54150     for( int i=0; i < numStrings; i++)
54151     {
54152       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54153     }
54154     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54155
54156     strcpy( array[0], "dali-csharp-app");
54157
54158     arg1 = &argC;
54159     arg2 = &argV;
54160   }
54161   if (!jarg3) {
54162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54163     return 0;
54164   }
54165   std::string arg3_str(jarg3);
54166   arg3 = &arg3_str;
54167   {
54168     try {
54169       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
54170     } catch (std::out_of_range& e) {
54171       {
54172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54173       };
54174     } catch (std::exception& e) {
54175       {
54176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54177       };
54178     } catch (...) {
54179       {
54180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54181       };
54182     }
54183   }
54184   jresult = new Dali::Application((const Dali::Application &)result);
54185
54186   //argout typemap for const std::string&
54187
54188   return jresult;
54189 }
54190
54191
54192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
54193   void * jresult ;
54194   int *arg1 = (int *) 0 ;
54195   char ***arg2 ;
54196   std::string *arg3 = 0 ;
54197   Dali::Application::WINDOW_MODE arg4 ;
54198   Dali::Application result;
54199
54200   {
54201     // Todo generate argv data from the C# args
54202     char **array;         // two dimensional array
54203     int numStrings = 1;     // number of strings
54204     int stringLength = 30;      // max string length.
54205     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54206     argV = array;
54207
54208     // allocate the string data
54209     for( int i=0; i < numStrings; i++)
54210     {
54211       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54212     }
54213     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54214
54215     strcpy( array[0], "dali-csharp-app");
54216
54217     arg1 = &argC;
54218     arg2 = &argV;
54219   }
54220   if (!jarg3) {
54221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54222     return 0;
54223   }
54224   std::string arg3_str(jarg3);
54225   arg3 = &arg3_str;
54226   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
54227   {
54228     try {
54229       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
54230     } catch (std::out_of_range& e) {
54231       {
54232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54233       };
54234     } catch (std::exception& e) {
54235       {
54236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54237       };
54238     } catch (...) {
54239       {
54240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54241       };
54242     }
54243   }
54244   jresult = new Dali::Application((const Dali::Application &)result);
54245
54246   //argout typemap for const std::string&
54247
54248   return jresult;
54249 }
54250
54251
54252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
54253   void * jresult ;
54254   Dali::Application *result = 0 ;
54255
54256   {
54257     try {
54258       result = (Dali::Application *)new Dali::Application();
54259     } catch (std::out_of_range& e) {
54260       {
54261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54262       };
54263     } catch (std::exception& e) {
54264       {
54265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54266       };
54267     } catch (...) {
54268       {
54269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54270       };
54271     }
54272   }
54273   jresult = (void *)result;
54274   return jresult;
54275 }
54276
54277
54278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
54279   void * jresult ;
54280   Dali::Application *arg1 = 0 ;
54281   Dali::Application *result = 0 ;
54282
54283   arg1 = (Dali::Application *)jarg1;
54284   if (!arg1) {
54285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54286     return 0;
54287   }
54288   {
54289     try {
54290       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
54291     } catch (std::out_of_range& e) {
54292       {
54293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54294       };
54295     } catch (std::exception& e) {
54296       {
54297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54298       };
54299     } catch (...) {
54300       {
54301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54302       };
54303     }
54304   }
54305   jresult = (void *)result;
54306   return jresult;
54307 }
54308
54309
54310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
54311   void * jresult ;
54312   Dali::Application *arg1 = (Dali::Application *) 0 ;
54313   Dali::Application *arg2 = 0 ;
54314   Dali::Application *result = 0 ;
54315
54316   arg1 = (Dali::Application *)jarg1;
54317   arg2 = (Dali::Application *)jarg2;
54318   if (!arg2) {
54319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54320     return 0;
54321   }
54322   {
54323     try {
54324       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
54325     } catch (std::out_of_range& e) {
54326       {
54327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54328       };
54329     } catch (std::exception& e) {
54330       {
54331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54332       };
54333     } catch (...) {
54334       {
54335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54336       };
54337     }
54338   }
54339   jresult = (void *)result;
54340   return jresult;
54341 }
54342
54343
54344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
54345   Dali::Application *arg1 = (Dali::Application *) 0 ;
54346
54347   arg1 = (Dali::Application *)jarg1;
54348   {
54349     try {
54350       delete arg1;
54351     } catch (std::out_of_range& e) {
54352       {
54353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54354       };
54355     } catch (std::exception& e) {
54356       {
54357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54358       };
54359     } catch (...) {
54360       {
54361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54362       };
54363     }
54364   }
54365 }
54366
54367
54368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
54369   Dali::Application *arg1 = (Dali::Application *) 0 ;
54370
54371   arg1 = (Dali::Application *)jarg1;
54372   {
54373     try {
54374       (arg1)->MainLoop();
54375     } catch (std::out_of_range& e) {
54376       {
54377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54378       };
54379     } catch (std::exception& e) {
54380       {
54381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54382       };
54383     } catch (...) {
54384       {
54385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54386       };
54387     }
54388   }
54389 }
54390
54391
54392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
54393   Dali::Application *arg1 = (Dali::Application *) 0 ;
54394   Configuration::ContextLoss arg2 ;
54395   Configuration::ContextLoss *argp2 ;
54396
54397   arg1 = (Dali::Application *)jarg1;
54398   argp2 = (Configuration::ContextLoss *)jarg2;
54399   if (!argp2) {
54400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
54401     return ;
54402   }
54403   arg2 = *argp2;
54404   {
54405     try {
54406       (arg1)->MainLoop(arg2);
54407     } catch (std::out_of_range& e) {
54408       {
54409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54410       };
54411     } catch (std::exception& e) {
54412       {
54413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54414       };
54415     } catch (...) {
54416       {
54417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54418       };
54419     }
54420   }
54421 }
54422
54423
54424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
54425   Dali::Application *arg1 = (Dali::Application *) 0 ;
54426
54427   arg1 = (Dali::Application *)jarg1;
54428   {
54429     try {
54430       (arg1)->Lower();
54431     } catch (std::out_of_range& e) {
54432       {
54433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54434       };
54435     } catch (std::exception& e) {
54436       {
54437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54438       };
54439     } catch (...) {
54440       {
54441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54442       };
54443     }
54444   }
54445 }
54446
54447
54448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
54449   Dali::Application *arg1 = (Dali::Application *) 0 ;
54450
54451   arg1 = (Dali::Application *)jarg1;
54452   {
54453     try {
54454       (arg1)->Quit();
54455     } catch (std::out_of_range& e) {
54456       {
54457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54458       };
54459     } catch (std::exception& e) {
54460       {
54461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54462       };
54463     } catch (...) {
54464       {
54465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54466       };
54467     }
54468   }
54469 }
54470
54471
54472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
54473   unsigned int jresult ;
54474   Dali::Application *arg1 = (Dali::Application *) 0 ;
54475   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
54476   bool result;
54477
54478   arg1 = (Dali::Application *)jarg1;
54479   arg2 = (Dali::CallbackBase *)jarg2;
54480   {
54481     try {
54482       result = (bool)(arg1)->AddIdle(arg2);
54483     } catch (std::out_of_range& e) {
54484       {
54485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54486       };
54487     } catch (std::exception& e) {
54488       {
54489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54490       };
54491     } catch (...) {
54492       {
54493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54494       };
54495     }
54496   }
54497   jresult = result;
54498   return jresult;
54499 }
54500
54501
54502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
54503   void * jresult ;
54504   Dali::Application *arg1 = (Dali::Application *) 0 ;
54505   Dali::Window result;
54506
54507   arg1 = (Dali::Application *)jarg1;
54508   {
54509     try {
54510       result = (arg1)->GetWindow();
54511     } catch (std::out_of_range& e) {
54512       {
54513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54514       };
54515     } catch (std::exception& e) {
54516       {
54517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54518       };
54519     } catch (...) {
54520       {
54521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54522       };
54523     }
54524   }
54525   jresult = new Dali::Window((const Dali::Window &)result);
54526   return jresult;
54527 }
54528
54529
54530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
54531   Dali::Application *arg1 = (Dali::Application *) 0 ;
54532   Dali::PositionSize arg2 ;
54533   std::string *arg3 = 0 ;
54534   Dali::PositionSize *argp2 ;
54535
54536   arg1 = (Dali::Application *)jarg1;
54537   argp2 = (Dali::PositionSize *)jarg2;
54538   if (!argp2) {
54539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54540     return ;
54541   }
54542   arg2 = *argp2;
54543   if (!jarg3) {
54544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54545     return ;
54546   }
54547   std::string arg3_str(jarg3);
54548   arg3 = &arg3_str;
54549   {
54550     try {
54551       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
54552     } catch (std::out_of_range& e) {
54553       {
54554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54555       };
54556     } catch (std::exception& e) {
54557       {
54558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54559       };
54560     } catch (...) {
54561       {
54562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54563       };
54564     }
54565   }
54566
54567   //argout typemap for const std::string&
54568
54569 }
54570
54571
54572 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
54573   char * jresult ;
54574   std::string result;
54575
54576   {
54577     try {
54578       result = Dali::Application::GetResourcePath();
54579     } catch (std::out_of_range& e) {
54580       {
54581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54582       };
54583     } catch (std::exception& e) {
54584       {
54585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54586       };
54587     } catch (...) {
54588       {
54589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54590       };
54591     }
54592   }
54593   jresult = SWIG_csharp_string_callback((&result)->c_str());
54594   return jresult;
54595 }
54596
54597
54598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
54599   Dali::Application *arg1 = (Dali::Application *) 0 ;
54600   Dali::ViewMode arg2 ;
54601
54602   arg1 = (Dali::Application *)jarg1;
54603   arg2 = (Dali::ViewMode)jarg2;
54604   {
54605     try {
54606       (arg1)->SetViewMode(arg2);
54607     } catch (std::out_of_range& e) {
54608       {
54609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54610       };
54611     } catch (std::exception& e) {
54612       {
54613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54614       };
54615     } catch (...) {
54616       {
54617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54618       };
54619     }
54620   }
54621 }
54622
54623
54624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
54625   int jresult ;
54626   Dali::Application *arg1 = (Dali::Application *) 0 ;
54627   Dali::ViewMode result;
54628
54629   arg1 = (Dali::Application *)jarg1;
54630   {
54631     try {
54632       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
54633     } catch (std::out_of_range& e) {
54634       {
54635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54636       };
54637     } catch (std::exception& e) {
54638       {
54639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54640       };
54641     } catch (...) {
54642       {
54643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54644       };
54645     }
54646   }
54647   jresult = (int)result;
54648   return jresult;
54649 }
54650
54651
54652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
54653   Dali::Application *arg1 = (Dali::Application *) 0 ;
54654   float arg2 ;
54655
54656   arg1 = (Dali::Application *)jarg1;
54657   arg2 = (float)jarg2;
54658   {
54659     try {
54660       (arg1)->SetStereoBase(arg2);
54661     } catch (std::out_of_range& e) {
54662       {
54663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54664       };
54665     } catch (std::exception& e) {
54666       {
54667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54668       };
54669     } catch (...) {
54670       {
54671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54672       };
54673     }
54674   }
54675 }
54676
54677
54678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
54679   float jresult ;
54680   Dali::Application *arg1 = (Dali::Application *) 0 ;
54681   float result;
54682
54683   arg1 = (Dali::Application *)jarg1;
54684   {
54685     try {
54686       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
54687     } catch (std::out_of_range& e) {
54688       {
54689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54690       };
54691     } catch (std::exception& e) {
54692       {
54693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54694       };
54695     } catch (...) {
54696       {
54697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54698       };
54699     }
54700   }
54701   jresult = result;
54702   return jresult;
54703 }
54704
54705
54706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
54707   void * jresult ;
54708   Dali::Application *arg1 = (Dali::Application *) 0 ;
54709   Dali::Application::AppSignalType *result = 0 ;
54710
54711   arg1 = (Dali::Application *)jarg1;
54712   {
54713     try {
54714       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
54715     } catch (std::out_of_range& e) {
54716       {
54717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54718       };
54719     } catch (std::exception& e) {
54720       {
54721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54722       };
54723     } catch (...) {
54724       {
54725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54726       };
54727     }
54728   }
54729   jresult = (void *)result;
54730   return jresult;
54731 }
54732
54733
54734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
54735   void * jresult ;
54736   Dali::Application *arg1 = (Dali::Application *) 0 ;
54737   Dali::Application::AppSignalType *result = 0 ;
54738
54739   arg1 = (Dali::Application *)jarg1;
54740   {
54741     try {
54742       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
54743     } catch (std::out_of_range& e) {
54744       {
54745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54746       };
54747     } catch (std::exception& e) {
54748       {
54749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54750       };
54751     } catch (...) {
54752       {
54753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54754       };
54755     }
54756   }
54757   jresult = (void *)result;
54758   return jresult;
54759 }
54760
54761
54762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
54763   void * jresult ;
54764   Dali::Application *arg1 = (Dali::Application *) 0 ;
54765   Dali::Application::AppSignalType *result = 0 ;
54766
54767   arg1 = (Dali::Application *)jarg1;
54768   {
54769     try {
54770       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
54771     } catch (std::out_of_range& e) {
54772       {
54773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54774       };
54775     } catch (std::exception& e) {
54776       {
54777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54778       };
54779     } catch (...) {
54780       {
54781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54782       };
54783     }
54784   }
54785   jresult = (void *)result;
54786   return jresult;
54787 }
54788
54789
54790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
54791   void * jresult ;
54792   Dali::Application *arg1 = (Dali::Application *) 0 ;
54793   Dali::Application::AppSignalType *result = 0 ;
54794
54795   arg1 = (Dali::Application *)jarg1;
54796   {
54797     try {
54798       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
54799     } catch (std::out_of_range& e) {
54800       {
54801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54802       };
54803     } catch (std::exception& e) {
54804       {
54805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54806       };
54807     } catch (...) {
54808       {
54809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54810       };
54811     }
54812   }
54813   jresult = (void *)result;
54814   return jresult;
54815 }
54816
54817
54818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
54819   void * jresult ;
54820   Dali::Application *arg1 = (Dali::Application *) 0 ;
54821   Dali::Application::AppSignalType *result = 0 ;
54822
54823   arg1 = (Dali::Application *)jarg1;
54824   {
54825     try {
54826       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
54827     } catch (std::out_of_range& e) {
54828       {
54829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54830       };
54831     } catch (std::exception& e) {
54832       {
54833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54834       };
54835     } catch (...) {
54836       {
54837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54838       };
54839     }
54840   }
54841   jresult = (void *)result;
54842   return jresult;
54843 }
54844
54845
54846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
54847   void * jresult ;
54848   Dali::Application *arg1 = (Dali::Application *) 0 ;
54849   Dali::Application::AppSignalType *result = 0 ;
54850
54851   arg1 = (Dali::Application *)jarg1;
54852   {
54853     try {
54854       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
54855     } catch (std::out_of_range& e) {
54856       {
54857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54858       };
54859     } catch (std::exception& e) {
54860       {
54861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54862       };
54863     } catch (...) {
54864       {
54865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54866       };
54867     }
54868   }
54869   jresult = (void *)result;
54870   return jresult;
54871 }
54872
54873
54874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
54875   void * jresult ;
54876   Dali::Application *arg1 = (Dali::Application *) 0 ;
54877   Dali::Application::AppControlSignalType *result = 0 ;
54878
54879   arg1 = (Dali::Application *)jarg1;
54880   {
54881     try {
54882       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
54883     } catch (std::out_of_range& e) {
54884       {
54885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54886       };
54887     } catch (std::exception& e) {
54888       {
54889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54890       };
54891     } catch (...) {
54892       {
54893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54894       };
54895     }
54896   }
54897   jresult = (void *)result;
54898   return jresult;
54899 }
54900
54901
54902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
54903   void * jresult ;
54904   Dali::Application *arg1 = (Dali::Application *) 0 ;
54905   Dali::Application::AppSignalType *result = 0 ;
54906
54907   arg1 = (Dali::Application *)jarg1;
54908   {
54909     try {
54910       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
54911     } catch (std::out_of_range& e) {
54912       {
54913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54914       };
54915     } catch (std::exception& e) {
54916       {
54917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54918       };
54919     } catch (...) {
54920       {
54921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54922       };
54923     }
54924   }
54925   jresult = (void *)result;
54926   return jresult;
54927 }
54928
54929
54930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
54931   void * jresult ;
54932   Dali::Application *arg1 = (Dali::Application *) 0 ;
54933   Dali::Application::AppSignalType *result = 0 ;
54934
54935   arg1 = (Dali::Application *)jarg1;
54936   {
54937     try {
54938       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
54939     } catch (std::out_of_range& e) {
54940       {
54941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54942       };
54943     } catch (std::exception& e) {
54944       {
54945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54946       };
54947     } catch (...) {
54948       {
54949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54950       };
54951     }
54952   }
54953   jresult = (void *)result;
54954   return jresult;
54955 }
54956
54957
54958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
54959   void * jresult ;
54960   Dali::Application *arg1 = (Dali::Application *) 0 ;
54961   Dali::Application::AppSignalType *result = 0 ;
54962
54963   arg1 = (Dali::Application *)jarg1;
54964   {
54965     try {
54966       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
54967     } catch (std::out_of_range& e) {
54968       {
54969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54970       };
54971     } catch (std::exception& e) {
54972       {
54973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54974       };
54975     } catch (...) {
54976       {
54977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54978       };
54979     }
54980   }
54981   jresult = (void *)result;
54982   return jresult;
54983 }
54984
54985
54986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
54987   void * jresult ;
54988   Dali::Application *arg1 = (Dali::Application *) 0 ;
54989   Dali::Application::AppSignalType *result = 0 ;
54990
54991   arg1 = (Dali::Application *)jarg1;
54992   {
54993     try {
54994       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
54995     } catch (std::out_of_range& e) {
54996       {
54997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54998       };
54999     } catch (std::exception& e) {
55000       {
55001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55002       };
55003     } catch (...) {
55004       {
55005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55006       };
55007     }
55008   }
55009   jresult = (void *)result;
55010   return jresult;
55011 }
55012
55013
55014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
55015   unsigned int jresult ;
55016   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55017   bool result;
55018
55019   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55020   {
55021     try {
55022       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
55023     } catch (std::out_of_range& e) {
55024       {
55025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55026       };
55027     } catch (std::exception& e) {
55028       {
55029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55030       };
55031     } catch (...) {
55032       {
55033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55034       };
55035     }
55036   }
55037   jresult = result;
55038   return jresult;
55039 }
55040
55041
55042 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
55043   unsigned long jresult ;
55044   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55045   std::size_t result;
55046
55047   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55048   {
55049     try {
55050       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
55051     } catch (std::out_of_range& e) {
55052       {
55053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55054       };
55055     } catch (std::exception& e) {
55056       {
55057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55058       };
55059     } catch (...) {
55060       {
55061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55062       };
55063     }
55064   }
55065   jresult = (unsigned long)result;
55066   return jresult;
55067 }
55068
55069
55070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
55071   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55072   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55073
55074   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55075   arg2 = (void (*)(Dali::Application &))jarg2;
55076   {
55077     try {
55078       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
55079     } catch (std::out_of_range& e) {
55080       {
55081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55082       };
55083     } catch (std::exception& e) {
55084       {
55085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55086       };
55087     } catch (...) {
55088       {
55089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55090       };
55091     }
55092   }
55093 }
55094
55095
55096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
55097   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55098   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55099
55100   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55101   arg2 = (void (*)(Dali::Application &))jarg2;
55102   {
55103     try {
55104       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
55105     } catch (std::out_of_range& e) {
55106       {
55107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55108       };
55109     } catch (std::exception& e) {
55110       {
55111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55112       };
55113     } catch (...) {
55114       {
55115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55116       };
55117     }
55118   }
55119 }
55120
55121
55122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
55123   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55124   Dali::Application *arg2 = 0 ;
55125
55126   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55127   arg2 = (Dali::Application *)jarg2;
55128   if (!arg2) {
55129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55130     return ;
55131   }
55132   {
55133     try {
55134       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
55135     } catch (std::out_of_range& e) {
55136       {
55137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55138       };
55139     } catch (std::exception& e) {
55140       {
55141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55142       };
55143     } catch (...) {
55144       {
55145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55146       };
55147     }
55148   }
55149 }
55150
55151
55152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
55153   void * jresult ;
55154   Dali::Signal< void (Dali::Application &) > *result = 0 ;
55155
55156   {
55157     try {
55158       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
55159     } catch (std::out_of_range& e) {
55160       {
55161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55162       };
55163     } catch (std::exception& e) {
55164       {
55165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55166       };
55167     } catch (...) {
55168       {
55169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55170       };
55171     }
55172   }
55173   jresult = (void *)result;
55174   return jresult;
55175 }
55176
55177
55178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
55179   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55180
55181   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55182   {
55183     try {
55184       delete arg1;
55185     } catch (std::out_of_range& e) {
55186       {
55187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55188       };
55189     } catch (std::exception& e) {
55190       {
55191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55192       };
55193     } catch (...) {
55194       {
55195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55196       };
55197     }
55198   }
55199 }
55200
55201
55202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
55203   unsigned int jresult ;
55204   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55205   bool result;
55206
55207   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55208   {
55209     try {
55210       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55211     } catch (std::out_of_range& e) {
55212       {
55213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55214       };
55215     } catch (std::exception& e) {
55216       {
55217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55218       };
55219     } catch (...) {
55220       {
55221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55222       };
55223     }
55224   }
55225   jresult = result;
55226   return jresult;
55227 }
55228
55229
55230 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
55231   unsigned long jresult ;
55232   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55233   std::size_t result;
55234
55235   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55236   {
55237     try {
55238       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55239     } catch (std::out_of_range& e) {
55240       {
55241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55242       };
55243     } catch (std::exception& e) {
55244       {
55245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55246       };
55247     } catch (...) {
55248       {
55249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55250       };
55251     }
55252   }
55253   jresult = (unsigned long)result;
55254   return jresult;
55255 }
55256
55257
55258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
55259   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55260   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55261
55262   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55263   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55264   {
55265     try {
55266       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
55267     } catch (std::out_of_range& e) {
55268       {
55269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55270       };
55271     } catch (std::exception& e) {
55272       {
55273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55274       };
55275     } catch (...) {
55276       {
55277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55278       };
55279     }
55280   }
55281 }
55282
55283
55284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
55285   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55286   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55287
55288   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55289   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55290   {
55291     try {
55292       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
55293     } catch (std::out_of_range& e) {
55294       {
55295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55296       };
55297     } catch (std::exception& e) {
55298       {
55299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55300       };
55301     } catch (...) {
55302       {
55303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55304       };
55305     }
55306   }
55307 }
55308
55309
55310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55311   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55312   Dali::Application *arg2 = 0 ;
55313   void *arg3 = (void *) 0 ;
55314
55315   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55316   arg2 = (Dali::Application *)jarg2;
55317   if (!arg2) {
55318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55319     return ;
55320   }
55321   arg3 = jarg3;
55322   {
55323     try {
55324       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
55325     } catch (std::out_of_range& e) {
55326       {
55327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55328       };
55329     } catch (std::exception& e) {
55330       {
55331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55332       };
55333     } catch (...) {
55334       {
55335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55336       };
55337     }
55338   }
55339 }
55340
55341
55342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
55343   void * jresult ;
55344   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
55345
55346   {
55347     try {
55348       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
55349     } catch (std::out_of_range& e) {
55350       {
55351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55352       };
55353     } catch (std::exception& e) {
55354       {
55355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55356       };
55357     } catch (...) {
55358       {
55359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55360       };
55361     }
55362   }
55363   jresult = (void *)result;
55364   return jresult;
55365 }
55366
55367
55368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
55369   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55370
55371   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55372   {
55373     try {
55374       delete arg1;
55375     } catch (std::out_of_range& e) {
55376       {
55377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55378       };
55379     } catch (std::exception& e) {
55380       {
55381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55382       };
55383     } catch (...) {
55384       {
55385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55386       };
55387     }
55388   }
55389 }
55390
55391
55392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55393   unsigned int jresult ;
55394   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55395   bool result;
55396
55397   arg1 = (Dali::Signal< bool () > *)jarg1;
55398   {
55399     try {
55400       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55401     } catch (std::out_of_range& e) {
55402       {
55403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55404       };
55405     } catch (std::exception& e) {
55406       {
55407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55408       };
55409     } catch (...) {
55410       {
55411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55412       };
55413     }
55414   }
55415   jresult = result;
55416   return jresult;
55417 }
55418
55419
55420 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55421   unsigned long jresult ;
55422   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55423   std::size_t result;
55424
55425   arg1 = (Dali::Signal< bool () > *)jarg1;
55426   {
55427     try {
55428       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55429     } catch (std::out_of_range& e) {
55430       {
55431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55432       };
55433     } catch (std::exception& e) {
55434       {
55435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55436       };
55437     } catch (...) {
55438       {
55439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55440       };
55441     }
55442   }
55443   jresult = (unsigned long)result;
55444   return jresult;
55445 }
55446
55447
55448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55449   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55450   bool (*arg2)() = (bool (*)()) 0 ;
55451
55452   arg1 = (Dali::Signal< bool () > *)jarg1;
55453   arg2 = (bool (*)())jarg2;
55454   {
55455     try {
55456       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55457     } catch (std::out_of_range& e) {
55458       {
55459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55460       };
55461     } catch (std::exception& e) {
55462       {
55463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55464       };
55465     } catch (...) {
55466       {
55467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55468       };
55469     }
55470   }
55471 }
55472
55473
55474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55475   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55476   bool (*arg2)() = (bool (*)()) 0 ;
55477
55478   arg1 = (Dali::Signal< bool () > *)jarg1;
55479   arg2 = (bool (*)())jarg2;
55480   {
55481     try {
55482       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55483     } catch (std::out_of_range& e) {
55484       {
55485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55486       };
55487     } catch (std::exception& e) {
55488       {
55489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55490       };
55491     } catch (...) {
55492       {
55493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55494       };
55495     }
55496   }
55497 }
55498
55499
55500 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55501   unsigned int jresult ;
55502   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55503   bool result;
55504
55505   arg1 = (Dali::Signal< bool () > *)jarg1;
55506   {
55507     try {
55508       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55509     } catch (std::out_of_range& e) {
55510       {
55511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55512       };
55513     } catch (std::exception& e) {
55514       {
55515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55516       };
55517     } catch (...) {
55518       {
55519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55520       };
55521     }
55522   }
55523   jresult = result;
55524   return jresult;
55525 }
55526
55527
55528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55529   void * jresult ;
55530   Dali::Signal< bool () > *result = 0 ;
55531
55532   {
55533     try {
55534       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55535     } catch (std::out_of_range& e) {
55536       {
55537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55538       };
55539     } catch (std::exception& e) {
55540       {
55541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55542       };
55543     } catch (...) {
55544       {
55545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55546       };
55547     }
55548   }
55549   jresult = (void *)result;
55550   return jresult;
55551 }
55552
55553
55554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55555   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55556
55557   arg1 = (Dali::Signal< bool () > *)jarg1;
55558   {
55559     try {
55560       delete arg1;
55561     } catch (std::out_of_range& e) {
55562       {
55563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55564       };
55565     } catch (std::exception& e) {
55566       {
55567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55568       };
55569     } catch (...) {
55570       {
55571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55572       };
55573     }
55574   }
55575 }
55576
55577
55578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55579   int jresult ;
55580   int result;
55581
55582   {
55583     try {
55584       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55585     } catch (std::out_of_range& e) {
55586       {
55587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55588       };
55589     } catch (std::exception& e) {
55590       {
55591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55592       };
55593     } catch (...) {
55594       {
55595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55596       };
55597     }
55598   }
55599   jresult = (int)result;
55600   return jresult;
55601 }
55602
55603
55604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55605   int jresult ;
55606   int result;
55607
55608   {
55609     try {
55610       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55611     } catch (std::out_of_range& e) {
55612       {
55613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55614       };
55615     } catch (std::exception& e) {
55616       {
55617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55618       };
55619     } catch (...) {
55620       {
55621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55622       };
55623     }
55624   }
55625   jresult = (int)result;
55626   return jresult;
55627 }
55628
55629
55630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55631   int jresult ;
55632   int result;
55633
55634   {
55635     try {
55636       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55637     } catch (std::out_of_range& e) {
55638       {
55639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55640       };
55641     } catch (std::exception& e) {
55642       {
55643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55644       };
55645     } catch (...) {
55646       {
55647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55648       };
55649     }
55650   }
55651   jresult = (int)result;
55652   return jresult;
55653 }
55654
55655
55656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55657   int jresult ;
55658   int result;
55659
55660   {
55661     try {
55662       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55663     } catch (std::out_of_range& e) {
55664       {
55665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55666       };
55667     } catch (std::exception& e) {
55668       {
55669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55670       };
55671     } catch (...) {
55672       {
55673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55674       };
55675     }
55676   }
55677   jresult = (int)result;
55678   return jresult;
55679 }
55680
55681
55682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55683   int jresult ;
55684   int result;
55685
55686   {
55687     try {
55688       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55689     } catch (std::out_of_range& e) {
55690       {
55691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55692       };
55693     } catch (std::exception& e) {
55694       {
55695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55696       };
55697     } catch (...) {
55698       {
55699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55700       };
55701     }
55702   }
55703   jresult = (int)result;
55704   return jresult;
55705 }
55706
55707
55708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55709   int jresult ;
55710   int result;
55711
55712   {
55713     try {
55714       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55715     } catch (std::out_of_range& e) {
55716       {
55717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55718       };
55719     } catch (std::exception& e) {
55720       {
55721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55722       };
55723     } catch (...) {
55724       {
55725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55726       };
55727     }
55728   }
55729   jresult = (int)result;
55730   return jresult;
55731 }
55732
55733
55734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55735   int jresult ;
55736   int result;
55737
55738   {
55739     try {
55740       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55741     } catch (std::out_of_range& e) {
55742       {
55743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55744       };
55745     } catch (std::exception& e) {
55746       {
55747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55748       };
55749     } catch (...) {
55750       {
55751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55752       };
55753     }
55754   }
55755   jresult = (int)result;
55756   return jresult;
55757 }
55758
55759
55760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55761   int jresult ;
55762   int result;
55763
55764   {
55765     try {
55766       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55767     } catch (std::out_of_range& e) {
55768       {
55769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55770       };
55771     } catch (std::exception& e) {
55772       {
55773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55774       };
55775     } catch (...) {
55776       {
55777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55778       };
55779     }
55780   }
55781   jresult = (int)result;
55782   return jresult;
55783 }
55784
55785
55786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55787   int jresult ;
55788   int result;
55789
55790   {
55791     try {
55792       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55793     } catch (std::out_of_range& e) {
55794       {
55795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55796       };
55797     } catch (std::exception& e) {
55798       {
55799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55800       };
55801     } catch (...) {
55802       {
55803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55804       };
55805     }
55806   }
55807   jresult = (int)result;
55808   return jresult;
55809 }
55810
55811
55812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55813   int jresult ;
55814   int result;
55815
55816   {
55817     try {
55818       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55819     } catch (std::out_of_range& e) {
55820       {
55821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55822       };
55823     } catch (std::exception& e) {
55824       {
55825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55826       };
55827     } catch (...) {
55828       {
55829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55830       };
55831     }
55832   }
55833   jresult = (int)result;
55834   return jresult;
55835 }
55836
55837
55838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55839   int jresult ;
55840   int result;
55841
55842   {
55843     try {
55844       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55845     } catch (std::out_of_range& e) {
55846       {
55847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55848       };
55849     } catch (std::exception& e) {
55850       {
55851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55852       };
55853     } catch (...) {
55854       {
55855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55856       };
55857     }
55858   }
55859   jresult = (int)result;
55860   return jresult;
55861 }
55862
55863
55864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55865   int jresult ;
55866   int result;
55867
55868   {
55869     try {
55870       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55871     } catch (std::out_of_range& e) {
55872       {
55873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55874       };
55875     } catch (std::exception& e) {
55876       {
55877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55878       };
55879     } catch (...) {
55880       {
55881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55882       };
55883     }
55884   }
55885   jresult = (int)result;
55886   return jresult;
55887 }
55888
55889
55890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55891   int jresult ;
55892   int result;
55893
55894   {
55895     try {
55896       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55897     } catch (std::out_of_range& e) {
55898       {
55899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55900       };
55901     } catch (std::exception& e) {
55902       {
55903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55904       };
55905     } catch (...) {
55906       {
55907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55908       };
55909     }
55910   }
55911   jresult = (int)result;
55912   return jresult;
55913 }
55914
55915
55916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55917   int jresult ;
55918   int result;
55919
55920   {
55921     try {
55922       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55923     } catch (std::out_of_range& e) {
55924       {
55925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55926       };
55927     } catch (std::exception& e) {
55928       {
55929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55930       };
55931     } catch (...) {
55932       {
55933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55934       };
55935     }
55936   }
55937   jresult = (int)result;
55938   return jresult;
55939 }
55940
55941
55942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55943   int jresult ;
55944   int result;
55945
55946   {
55947     try {
55948       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55949     } catch (std::out_of_range& e) {
55950       {
55951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55952       };
55953     } catch (std::exception& e) {
55954       {
55955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55956       };
55957     } catch (...) {
55958       {
55959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55960       };
55961     }
55962   }
55963   jresult = (int)result;
55964   return jresult;
55965 }
55966
55967
55968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55969   int jresult ;
55970   int result;
55971
55972   {
55973     try {
55974       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55975     } catch (std::out_of_range& e) {
55976       {
55977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55978       };
55979     } catch (std::exception& e) {
55980       {
55981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55982       };
55983     } catch (...) {
55984       {
55985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55986       };
55987     }
55988   }
55989   jresult = (int)result;
55990   return jresult;
55991 }
55992
55993
55994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55995   int jresult ;
55996   int result;
55997
55998   {
55999     try {
56000       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
56001     } catch (std::out_of_range& e) {
56002       {
56003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56004       };
56005     } catch (std::exception& e) {
56006       {
56007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56008       };
56009     } catch (...) {
56010       {
56011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56012       };
56013     }
56014   }
56015   jresult = (int)result;
56016   return jresult;
56017 }
56018
56019
56020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56021   int jresult ;
56022   int result;
56023
56024   {
56025     try {
56026       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56027     } catch (std::out_of_range& e) {
56028       {
56029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56030       };
56031     } catch (std::exception& e) {
56032       {
56033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56034       };
56035     } catch (...) {
56036       {
56037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56038       };
56039     }
56040   }
56041   jresult = (int)result;
56042   return jresult;
56043 }
56044
56045
56046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56047   int jresult ;
56048   int result;
56049
56050   {
56051     try {
56052       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56053     } catch (std::out_of_range& e) {
56054       {
56055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56056       };
56057     } catch (std::exception& e) {
56058       {
56059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56060       };
56061     } catch (...) {
56062       {
56063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56064       };
56065     }
56066   }
56067   jresult = (int)result;
56068   return jresult;
56069 }
56070
56071
56072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56073   int jresult ;
56074   int result;
56075
56076   {
56077     try {
56078       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56079     } catch (std::out_of_range& e) {
56080       {
56081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56082       };
56083     } catch (std::exception& e) {
56084       {
56085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56086       };
56087     } catch (...) {
56088       {
56089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56090       };
56091     }
56092   }
56093   jresult = (int)result;
56094   return jresult;
56095 }
56096
56097
56098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56099   int jresult ;
56100   int result;
56101
56102   {
56103     try {
56104       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56105     } catch (std::out_of_range& e) {
56106       {
56107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56108       };
56109     } catch (std::exception& e) {
56110       {
56111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56112       };
56113     } catch (...) {
56114       {
56115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56116       };
56117     }
56118   }
56119   jresult = (int)result;
56120   return jresult;
56121 }
56122
56123
56124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56125   int jresult ;
56126   int result;
56127
56128   {
56129     try {
56130       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56131     } catch (std::out_of_range& e) {
56132       {
56133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56134       };
56135     } catch (std::exception& e) {
56136       {
56137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56138       };
56139     } catch (...) {
56140       {
56141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56142       };
56143     }
56144   }
56145   jresult = (int)result;
56146   return jresult;
56147 }
56148
56149
56150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56151   int jresult ;
56152   int result;
56153
56154   {
56155     try {
56156       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56157     } catch (std::out_of_range& e) {
56158       {
56159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56160       };
56161     } catch (std::exception& e) {
56162       {
56163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56164       };
56165     } catch (...) {
56166       {
56167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56168       };
56169     }
56170   }
56171   jresult = (int)result;
56172   return jresult;
56173 }
56174
56175
56176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56177   int jresult ;
56178   int result;
56179
56180   {
56181     try {
56182       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56183     } catch (std::out_of_range& e) {
56184       {
56185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56186       };
56187     } catch (std::exception& e) {
56188       {
56189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56190       };
56191     } catch (...) {
56192       {
56193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56194       };
56195     }
56196   }
56197   jresult = (int)result;
56198   return jresult;
56199 }
56200
56201
56202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56203   int jresult ;
56204   int result;
56205
56206   {
56207     try {
56208       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56209     } catch (std::out_of_range& e) {
56210       {
56211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56212       };
56213     } catch (std::exception& e) {
56214       {
56215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56216       };
56217     } catch (...) {
56218       {
56219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56220       };
56221     }
56222   }
56223   jresult = (int)result;
56224   return jresult;
56225 }
56226
56227
56228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56229   int jresult ;
56230   int result;
56231
56232   {
56233     try {
56234       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56235     } catch (std::out_of_range& e) {
56236       {
56237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56238       };
56239     } catch (std::exception& e) {
56240       {
56241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56242       };
56243     } catch (...) {
56244       {
56245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56246       };
56247     }
56248   }
56249   jresult = (int)result;
56250   return jresult;
56251 }
56252
56253
56254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56255   int jresult ;
56256   int result;
56257
56258   {
56259     try {
56260       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56261     } catch (std::out_of_range& e) {
56262       {
56263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56264       };
56265     } catch (std::exception& e) {
56266       {
56267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56268       };
56269     } catch (...) {
56270       {
56271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56272       };
56273     }
56274   }
56275   jresult = (int)result;
56276   return jresult;
56277 }
56278
56279
56280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56281   int jresult ;
56282   int result;
56283
56284   {
56285     try {
56286       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56287     } catch (std::out_of_range& e) {
56288       {
56289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56290       };
56291     } catch (std::exception& e) {
56292       {
56293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56294       };
56295     } catch (...) {
56296       {
56297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56298       };
56299     }
56300   }
56301   jresult = (int)result;
56302   return jresult;
56303 }
56304
56305
56306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56307   int jresult ;
56308   int result;
56309
56310   {
56311     try {
56312       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56313     } catch (std::out_of_range& e) {
56314       {
56315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56316       };
56317     } catch (std::exception& e) {
56318       {
56319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56320       };
56321     } catch (...) {
56322       {
56323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56324       };
56325     }
56326   }
56327   jresult = (int)result;
56328   return jresult;
56329 }
56330
56331
56332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56333   int jresult ;
56334   int result;
56335
56336   {
56337     try {
56338       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56339     } catch (std::out_of_range& e) {
56340       {
56341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56342       };
56343     } catch (std::exception& e) {
56344       {
56345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56346       };
56347     } catch (...) {
56348       {
56349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56350       };
56351     }
56352   }
56353   jresult = (int)result;
56354   return jresult;
56355 }
56356
56357
56358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56359   int jresult ;
56360   int result;
56361
56362   {
56363     try {
56364       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56365     } catch (std::out_of_range& e) {
56366       {
56367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56368       };
56369     } catch (std::exception& e) {
56370       {
56371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56372       };
56373     } catch (...) {
56374       {
56375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56376       };
56377     }
56378   }
56379   jresult = (int)result;
56380   return jresult;
56381 }
56382
56383
56384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56385   int jresult ;
56386   int result;
56387
56388   {
56389     try {
56390       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56391     } catch (std::out_of_range& e) {
56392       {
56393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56394       };
56395     } catch (std::exception& e) {
56396       {
56397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56398       };
56399     } catch (...) {
56400       {
56401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56402       };
56403     }
56404   }
56405   jresult = (int)result;
56406   return jresult;
56407 }
56408
56409
56410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56411   int jresult ;
56412   int result;
56413
56414   {
56415     try {
56416       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56417     } catch (std::out_of_range& e) {
56418       {
56419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56420       };
56421     } catch (std::exception& e) {
56422       {
56423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56424       };
56425     } catch (...) {
56426       {
56427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56428       };
56429     }
56430   }
56431   jresult = (int)result;
56432   return jresult;
56433 }
56434
56435
56436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56437   int jresult ;
56438   int result;
56439
56440   {
56441     try {
56442       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56443     } catch (std::out_of_range& e) {
56444       {
56445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56446       };
56447     } catch (std::exception& e) {
56448       {
56449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56450       };
56451     } catch (...) {
56452       {
56453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56454       };
56455     }
56456   }
56457   jresult = (int)result;
56458   return jresult;
56459 }
56460
56461
56462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56463   int jresult ;
56464   int result;
56465
56466   {
56467     try {
56468       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
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 (...) {
56478       {
56479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56480       };
56481     }
56482   }
56483   jresult = (int)result;
56484   return jresult;
56485 }
56486
56487
56488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56489   int jresult ;
56490   int result;
56491
56492   {
56493     try {
56494       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56495     } catch (std::out_of_range& e) {
56496       {
56497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56498       };
56499     } catch (std::exception& e) {
56500       {
56501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56502       };
56503     } catch (...) {
56504       {
56505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56506       };
56507     }
56508   }
56509   jresult = (int)result;
56510   return jresult;
56511 }
56512
56513
56514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56515   int jresult ;
56516   int result;
56517
56518   {
56519     try {
56520       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56521     } catch (std::out_of_range& e) {
56522       {
56523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56524       };
56525     } catch (std::exception& e) {
56526       {
56527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56528       };
56529     } catch (...) {
56530       {
56531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56532       };
56533     }
56534   }
56535   jresult = (int)result;
56536   return jresult;
56537 }
56538
56539
56540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56541   int jresult ;
56542   int result;
56543
56544   {
56545     try {
56546       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56547     } catch (std::out_of_range& e) {
56548       {
56549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56550       };
56551     } catch (std::exception& e) {
56552       {
56553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56554       };
56555     } catch (...) {
56556       {
56557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56558       };
56559     }
56560   }
56561   jresult = (int)result;
56562   return jresult;
56563 }
56564
56565
56566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56567   int jresult ;
56568   int result;
56569
56570   {
56571     try {
56572       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56573     } catch (std::out_of_range& e) {
56574       {
56575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56576       };
56577     } catch (std::exception& e) {
56578       {
56579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56580       };
56581     } catch (...) {
56582       {
56583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56584       };
56585     }
56586   }
56587   jresult = (int)result;
56588   return jresult;
56589 }
56590
56591
56592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56593   int jresult ;
56594   int result;
56595
56596   {
56597     try {
56598       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56599     } catch (std::out_of_range& e) {
56600       {
56601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56602       };
56603     } catch (std::exception& e) {
56604       {
56605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56606       };
56607     } catch (...) {
56608       {
56609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56610       };
56611     }
56612   }
56613   jresult = (int)result;
56614   return jresult;
56615 }
56616
56617
56618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56619   int jresult ;
56620   int result;
56621
56622   {
56623     try {
56624       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56625     } catch (std::out_of_range& e) {
56626       {
56627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56628       };
56629     } catch (std::exception& e) {
56630       {
56631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56632       };
56633     } catch (...) {
56634       {
56635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56636       };
56637     }
56638   }
56639   jresult = (int)result;
56640   return jresult;
56641 }
56642
56643
56644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56645   int jresult ;
56646   int result;
56647
56648   {
56649     try {
56650       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56651     } catch (std::out_of_range& e) {
56652       {
56653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56654       };
56655     } catch (std::exception& e) {
56656       {
56657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56658       };
56659     } catch (...) {
56660       {
56661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56662       };
56663     }
56664   }
56665   jresult = (int)result;
56666   return jresult;
56667 }
56668
56669
56670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56671   int jresult ;
56672   int result;
56673
56674   {
56675     try {
56676       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56677     } catch (std::out_of_range& e) {
56678       {
56679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56680       };
56681     } catch (std::exception& e) {
56682       {
56683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56684       };
56685     } catch (...) {
56686       {
56687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56688       };
56689     }
56690   }
56691   jresult = (int)result;
56692   return jresult;
56693 }
56694
56695
56696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56697   int jresult ;
56698   int result;
56699
56700   {
56701     try {
56702       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56703     } catch (std::out_of_range& e) {
56704       {
56705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56706       };
56707     } catch (std::exception& e) {
56708       {
56709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56710       };
56711     } catch (...) {
56712       {
56713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56714       };
56715     }
56716   }
56717   jresult = (int)result;
56718   return jresult;
56719 }
56720
56721
56722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56723   int jresult ;
56724   int result;
56725
56726   {
56727     try {
56728       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56729     } catch (std::out_of_range& e) {
56730       {
56731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56732       };
56733     } catch (std::exception& e) {
56734       {
56735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56736       };
56737     } catch (...) {
56738       {
56739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56740       };
56741     }
56742   }
56743   jresult = (int)result;
56744   return jresult;
56745 }
56746
56747
56748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56749   int jresult ;
56750   int result;
56751
56752   {
56753     try {
56754       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56755     } catch (std::out_of_range& e) {
56756       {
56757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56758       };
56759     } catch (std::exception& e) {
56760       {
56761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56762       };
56763     } catch (...) {
56764       {
56765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56766       };
56767     }
56768   }
56769   jresult = (int)result;
56770   return jresult;
56771 }
56772
56773
56774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56775   int jresult ;
56776   int result;
56777
56778   {
56779     try {
56780       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56781     } catch (std::out_of_range& e) {
56782       {
56783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56784       };
56785     } catch (std::exception& e) {
56786       {
56787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56788       };
56789     } catch (...) {
56790       {
56791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56792       };
56793     }
56794   }
56795   jresult = (int)result;
56796   return jresult;
56797 }
56798
56799
56800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
56801   int jresult ;
56802   int result;
56803
56804   {
56805     try {
56806       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
56807     } catch (std::out_of_range& e) {
56808       {
56809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56810       };
56811     } catch (std::exception& e) {
56812       {
56813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56814       };
56815     } catch (...) {
56816       {
56817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56818       };
56819     }
56820   }
56821   jresult = (int)result;
56822   return jresult;
56823 }
56824
56825
56826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
56827   int jresult ;
56828   int result;
56829
56830   {
56831     try {
56832       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
56833     } catch (std::out_of_range& e) {
56834       {
56835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56836       };
56837     } catch (std::exception& e) {
56838       {
56839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56840       };
56841     } catch (...) {
56842       {
56843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56844       };
56845     }
56846   }
56847   jresult = (int)result;
56848   return jresult;
56849 }
56850
56851
56852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
56853   int jresult ;
56854   int result;
56855
56856   {
56857     try {
56858       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
56859     } catch (std::out_of_range& e) {
56860       {
56861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56862       };
56863     } catch (std::exception& e) {
56864       {
56865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56866       };
56867     } catch (...) {
56868       {
56869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56870       };
56871     }
56872   }
56873   jresult = (int)result;
56874   return jresult;
56875 }
56876
56877
56878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
56879   int jresult ;
56880   int result;
56881
56882   {
56883     try {
56884       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
56885     } catch (std::out_of_range& e) {
56886       {
56887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56888       };
56889     } catch (std::exception& e) {
56890       {
56891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56892       };
56893     } catch (...) {
56894       {
56895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56896       };
56897     }
56898   }
56899   jresult = (int)result;
56900   return jresult;
56901 }
56902
56903
56904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
56905   int jresult ;
56906   int result;
56907
56908   {
56909     try {
56910       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
56911     } catch (std::out_of_range& e) {
56912       {
56913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56914       };
56915     } catch (std::exception& e) {
56916       {
56917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56918       };
56919     } catch (...) {
56920       {
56921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56922       };
56923     }
56924   }
56925   jresult = (int)result;
56926   return jresult;
56927 }
56928
56929
56930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
56931   int jresult ;
56932   int result;
56933
56934   {
56935     try {
56936       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
56937     } catch (std::out_of_range& e) {
56938       {
56939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56940       };
56941     } catch (std::exception& e) {
56942       {
56943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56944       };
56945     } catch (...) {
56946       {
56947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56948       };
56949     }
56950   }
56951   jresult = (int)result;
56952   return jresult;
56953 }
56954
56955
56956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
56957   int jresult ;
56958   int result;
56959
56960   {
56961     try {
56962       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
56963     } catch (std::out_of_range& e) {
56964       {
56965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56966       };
56967     } catch (std::exception& e) {
56968       {
56969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56970       };
56971     } catch (...) {
56972       {
56973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56974       };
56975     }
56976   }
56977   jresult = (int)result;
56978   return jresult;
56979 }
56980
56981
56982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
56983   int jresult ;
56984   int result;
56985
56986   {
56987     try {
56988       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
56989     } catch (std::out_of_range& e) {
56990       {
56991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56992       };
56993     } catch (std::exception& e) {
56994       {
56995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56996       };
56997     } catch (...) {
56998       {
56999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57000       };
57001     }
57002   }
57003   jresult = (int)result;
57004   return jresult;
57005 }
57006
57007
57008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57009   int jresult ;
57010   int result;
57011
57012   {
57013     try {
57014       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57015     } catch (std::out_of_range& e) {
57016       {
57017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57018       };
57019     } catch (std::exception& e) {
57020       {
57021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57022       };
57023     } catch (...) {
57024       {
57025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57026       };
57027     }
57028   }
57029   jresult = (int)result;
57030   return jresult;
57031 }
57032
57033
57034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57035   int jresult ;
57036   int result;
57037
57038   {
57039     try {
57040       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57041     } catch (std::out_of_range& e) {
57042       {
57043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57044       };
57045     } catch (std::exception& e) {
57046       {
57047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57048       };
57049     } catch (...) {
57050       {
57051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57052       };
57053     }
57054   }
57055   jresult = (int)result;
57056   return jresult;
57057 }
57058
57059
57060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57061   void * jresult ;
57062   Dali::Toolkit::Builder *result = 0 ;
57063
57064   {
57065     try {
57066       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57067     } catch (std::out_of_range& e) {
57068       {
57069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57070       };
57071     } catch (std::exception& e) {
57072       {
57073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57074       };
57075     } catch (...) {
57076       {
57077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57078       };
57079     }
57080   }
57081   jresult = (void *)result;
57082   return jresult;
57083 }
57084
57085
57086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57087   void * jresult ;
57088   Dali::Toolkit::Builder result;
57089
57090   {
57091     try {
57092       result = Dali::Toolkit::Builder::New();
57093     } catch (std::out_of_range& e) {
57094       {
57095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57096       };
57097     } catch (std::exception& e) {
57098       {
57099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57100       };
57101     } catch (...) {
57102       {
57103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57104       };
57105     }
57106   }
57107   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57108   return jresult;
57109 }
57110
57111
57112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57113   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57114
57115   arg1 = (Dali::Toolkit::Builder *)jarg1;
57116   {
57117     try {
57118       delete arg1;
57119     } catch (std::out_of_range& e) {
57120       {
57121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57122       };
57123     } catch (std::exception& e) {
57124       {
57125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57126       };
57127     } catch (...) {
57128       {
57129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57130       };
57131     }
57132   }
57133 }
57134
57135
57136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57137   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57138   std::string *arg2 = 0 ;
57139   Dali::Toolkit::Builder::UIFormat arg3 ;
57140
57141   arg1 = (Dali::Toolkit::Builder *)jarg1;
57142   if (!jarg2) {
57143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57144     return ;
57145   }
57146   std::string arg2_str(jarg2);
57147   arg2 = &arg2_str;
57148   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57149   {
57150     try {
57151       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57152     } catch (std::out_of_range& e) {
57153       {
57154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57155       };
57156     } catch (std::exception& e) {
57157       {
57158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57159       };
57160     } catch (...) {
57161       {
57162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57163       };
57164     }
57165   }
57166
57167   //argout typemap for const std::string&
57168
57169 }
57170
57171
57172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57173   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57174   std::string *arg2 = 0 ;
57175
57176   arg1 = (Dali::Toolkit::Builder *)jarg1;
57177   if (!jarg2) {
57178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57179     return ;
57180   }
57181   std::string arg2_str(jarg2);
57182   arg2 = &arg2_str;
57183   {
57184     try {
57185       (arg1)->LoadFromString((std::string const &)*arg2);
57186     } catch (std::out_of_range& e) {
57187       {
57188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57189       };
57190     } catch (std::exception& e) {
57191       {
57192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57193       };
57194     } catch (...) {
57195       {
57196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57197       };
57198     }
57199   }
57200
57201   //argout typemap for const std::string&
57202
57203 }
57204
57205
57206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57207   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57208   Dali::Property::Map *arg2 = 0 ;
57209
57210   arg1 = (Dali::Toolkit::Builder *)jarg1;
57211   arg2 = (Dali::Property::Map *)jarg2;
57212   if (!arg2) {
57213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57214     return ;
57215   }
57216   {
57217     try {
57218       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57219     } catch (std::out_of_range& e) {
57220       {
57221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57222       };
57223     } catch (std::exception& e) {
57224       {
57225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57226       };
57227     } catch (...) {
57228       {
57229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57230       };
57231     }
57232   }
57233 }
57234
57235
57236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57237   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57238   std::string *arg2 = 0 ;
57239   Dali::Property::Value *arg3 = 0 ;
57240
57241   arg1 = (Dali::Toolkit::Builder *)jarg1;
57242   if (!jarg2) {
57243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57244     return ;
57245   }
57246   std::string arg2_str(jarg2);
57247   arg2 = &arg2_str;
57248   arg3 = (Dali::Property::Value *)jarg3;
57249   if (!arg3) {
57250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57251     return ;
57252   }
57253   {
57254     try {
57255       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57256     } catch (std::out_of_range& e) {
57257       {
57258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57259       };
57260     } catch (std::exception& e) {
57261       {
57262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57263       };
57264     } catch (...) {
57265       {
57266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57267       };
57268     }
57269   }
57270
57271   //argout typemap for const std::string&
57272
57273 }
57274
57275
57276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57277   void * jresult ;
57278   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57279   Dali::Property::Map *result = 0 ;
57280
57281   arg1 = (Dali::Toolkit::Builder *)jarg1;
57282   {
57283     try {
57284       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57285     } catch (std::out_of_range& e) {
57286       {
57287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57288       };
57289     } catch (std::exception& e) {
57290       {
57291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57292       };
57293     } catch (...) {
57294       {
57295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57296       };
57297     }
57298   }
57299   jresult = (void *)result;
57300   return jresult;
57301 }
57302
57303
57304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57305   void * jresult ;
57306   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57307   std::string *arg2 = 0 ;
57308   Dali::Property::Value *result = 0 ;
57309
57310   arg1 = (Dali::Toolkit::Builder *)jarg1;
57311   if (!jarg2) {
57312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57313     return 0;
57314   }
57315   std::string arg2_str(jarg2);
57316   arg2 = &arg2_str;
57317   {
57318     try {
57319       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57320     } catch (std::out_of_range& e) {
57321       {
57322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57323       };
57324     } catch (std::exception& e) {
57325       {
57326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57327       };
57328     } catch (...) {
57329       {
57330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57331       };
57332     }
57333   }
57334   jresult = (void *)result;
57335
57336   //argout typemap for const std::string&
57337
57338   return jresult;
57339 }
57340
57341
57342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57343   void * jresult ;
57344   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57345   std::string *arg2 = 0 ;
57346   Dali::Animation result;
57347
57348   arg1 = (Dali::Toolkit::Builder *)jarg1;
57349   if (!jarg2) {
57350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57351     return 0;
57352   }
57353   std::string arg2_str(jarg2);
57354   arg2 = &arg2_str;
57355   {
57356     try {
57357       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57358     } catch (std::out_of_range& e) {
57359       {
57360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57361       };
57362     } catch (std::exception& e) {
57363       {
57364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57365       };
57366     } catch (...) {
57367       {
57368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57369       };
57370     }
57371   }
57372   jresult = new Dali::Animation((const Dali::Animation &)result);
57373
57374   //argout typemap for const std::string&
57375
57376   return jresult;
57377 }
57378
57379
57380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57381   void * jresult ;
57382   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57383   std::string *arg2 = 0 ;
57384   Dali::Property::Map *arg3 = 0 ;
57385   Dali::Animation result;
57386
57387   arg1 = (Dali::Toolkit::Builder *)jarg1;
57388   if (!jarg2) {
57389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57390     return 0;
57391   }
57392   std::string arg2_str(jarg2);
57393   arg2 = &arg2_str;
57394   arg3 = (Dali::Property::Map *)jarg3;
57395   if (!arg3) {
57396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57397     return 0;
57398   }
57399   {
57400     try {
57401       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57402     } catch (std::out_of_range& e) {
57403       {
57404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57405       };
57406     } catch (std::exception& e) {
57407       {
57408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57409       };
57410     } catch (...) {
57411       {
57412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57413       };
57414     }
57415   }
57416   jresult = new Dali::Animation((const Dali::Animation &)result);
57417
57418   //argout typemap for const std::string&
57419
57420   return jresult;
57421 }
57422
57423
57424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57425   void * jresult ;
57426   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57427   std::string *arg2 = 0 ;
57428   Dali::Actor arg3 ;
57429   Dali::Actor *argp3 ;
57430   Dali::Animation result;
57431
57432   arg1 = (Dali::Toolkit::Builder *)jarg1;
57433   if (!jarg2) {
57434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57435     return 0;
57436   }
57437   std::string arg2_str(jarg2);
57438   arg2 = &arg2_str;
57439   argp3 = (Dali::Actor *)jarg3;
57440   if (!argp3) {
57441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57442     return 0;
57443   }
57444   arg3 = *argp3;
57445   {
57446     try {
57447       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57448     } catch (std::out_of_range& e) {
57449       {
57450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57451       };
57452     } catch (std::exception& e) {
57453       {
57454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57455       };
57456     } catch (...) {
57457       {
57458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57459       };
57460     }
57461   }
57462   jresult = new Dali::Animation((const Dali::Animation &)result);
57463
57464   //argout typemap for const std::string&
57465
57466   return jresult;
57467 }
57468
57469
57470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57471   void * jresult ;
57472   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57473   std::string *arg2 = 0 ;
57474   Dali::Property::Map *arg3 = 0 ;
57475   Dali::Actor arg4 ;
57476   Dali::Actor *argp4 ;
57477   Dali::Animation result;
57478
57479   arg1 = (Dali::Toolkit::Builder *)jarg1;
57480   if (!jarg2) {
57481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57482     return 0;
57483   }
57484   std::string arg2_str(jarg2);
57485   arg2 = &arg2_str;
57486   arg3 = (Dali::Property::Map *)jarg3;
57487   if (!arg3) {
57488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57489     return 0;
57490   }
57491   argp4 = (Dali::Actor *)jarg4;
57492   if (!argp4) {
57493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57494     return 0;
57495   }
57496   arg4 = *argp4;
57497   {
57498     try {
57499       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57500     } catch (std::out_of_range& e) {
57501       {
57502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57503       };
57504     } catch (std::exception& e) {
57505       {
57506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57507       };
57508     } catch (...) {
57509       {
57510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57511       };
57512     }
57513   }
57514   jresult = new Dali::Animation((const Dali::Animation &)result);
57515
57516   //argout typemap for const std::string&
57517
57518   return jresult;
57519 }
57520
57521
57522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57523   void * jresult ;
57524   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57525   std::string *arg2 = 0 ;
57526   Dali::BaseHandle result;
57527
57528   arg1 = (Dali::Toolkit::Builder *)jarg1;
57529   if (!jarg2) {
57530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57531     return 0;
57532   }
57533   std::string arg2_str(jarg2);
57534   arg2 = &arg2_str;
57535   {
57536     try {
57537       result = (arg1)->Create((std::string const &)*arg2);
57538     } catch (std::out_of_range& e) {
57539       {
57540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57541       };
57542     } catch (std::exception& e) {
57543       {
57544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57545       };
57546     } catch (...) {
57547       {
57548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57549       };
57550     }
57551   }
57552   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57553
57554   //argout typemap for const std::string&
57555
57556   return jresult;
57557 }
57558
57559
57560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57561   void * jresult ;
57562   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57563   std::string *arg2 = 0 ;
57564   Dali::Property::Map *arg3 = 0 ;
57565   Dali::BaseHandle result;
57566
57567   arg1 = (Dali::Toolkit::Builder *)jarg1;
57568   if (!jarg2) {
57569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57570     return 0;
57571   }
57572   std::string arg2_str(jarg2);
57573   arg2 = &arg2_str;
57574   arg3 = (Dali::Property::Map *)jarg3;
57575   if (!arg3) {
57576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57577     return 0;
57578   }
57579   {
57580     try {
57581       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57582     } catch (std::out_of_range& e) {
57583       {
57584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57585       };
57586     } catch (std::exception& e) {
57587       {
57588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57589       };
57590     } catch (...) {
57591       {
57592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57593       };
57594     }
57595   }
57596   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57597
57598   //argout typemap for const std::string&
57599
57600   return jresult;
57601 }
57602
57603
57604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57605   void * jresult ;
57606   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57607   std::string *arg2 = 0 ;
57608   Dali::BaseHandle result;
57609
57610   arg1 = (Dali::Toolkit::Builder *)jarg1;
57611   if (!jarg2) {
57612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57613     return 0;
57614   }
57615   std::string arg2_str(jarg2);
57616   arg2 = &arg2_str;
57617   {
57618     try {
57619       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57620     } catch (std::out_of_range& e) {
57621       {
57622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57623       };
57624     } catch (std::exception& e) {
57625       {
57626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57627       };
57628     } catch (...) {
57629       {
57630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57631       };
57632     }
57633   }
57634   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57635
57636   //argout typemap for const std::string&
57637
57638   return jresult;
57639 }
57640
57641
57642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57643   unsigned int jresult ;
57644   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57645   std::string *arg2 = 0 ;
57646   Dali::Handle *arg3 = 0 ;
57647   bool result;
57648
57649   arg1 = (Dali::Toolkit::Builder *)jarg1;
57650   if (!jarg2) {
57651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57652     return 0;
57653   }
57654   std::string arg2_str(jarg2);
57655   arg2 = &arg2_str;
57656   arg3 = (Dali::Handle *)jarg3;
57657   if (!arg3) {
57658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57659     return 0;
57660   }
57661   {
57662     try {
57663       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
57664     } catch (std::out_of_range& e) {
57665       {
57666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57667       };
57668     } catch (std::exception& e) {
57669       {
57670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57671       };
57672     } catch (...) {
57673       {
57674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57675       };
57676     }
57677   }
57678   jresult = result;
57679
57680   //argout typemap for const std::string&
57681
57682   return jresult;
57683 }
57684
57685
57686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
57687   unsigned int jresult ;
57688   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57689   Dali::Handle *arg2 = 0 ;
57690   std::string *arg3 = 0 ;
57691   bool result;
57692
57693   arg1 = (Dali::Toolkit::Builder *)jarg1;
57694   arg2 = (Dali::Handle *)jarg2;
57695   if (!arg2) {
57696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57697     return 0;
57698   }
57699   if (!jarg3) {
57700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57701     return 0;
57702   }
57703   std::string arg3_str(jarg3);
57704   arg3 = &arg3_str;
57705   {
57706     try {
57707       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
57708     } catch (std::out_of_range& e) {
57709       {
57710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57711       };
57712     } catch (std::exception& e) {
57713       {
57714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57715       };
57716     } catch (...) {
57717       {
57718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57719       };
57720     }
57721   }
57722   jresult = result;
57723
57724   //argout typemap for const std::string&
57725
57726   return jresult;
57727 }
57728
57729
57730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
57731   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57732   Dali::Actor arg2 ;
57733   Dali::Actor *argp2 ;
57734
57735   arg1 = (Dali::Toolkit::Builder *)jarg1;
57736   argp2 = (Dali::Actor *)jarg2;
57737   if (!argp2) {
57738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57739     return ;
57740   }
57741   arg2 = *argp2;
57742   {
57743     try {
57744       (arg1)->AddActors(arg2);
57745     } catch (std::out_of_range& e) {
57746       {
57747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57748       };
57749     } catch (std::exception& e) {
57750       {
57751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57752       };
57753     } catch (...) {
57754       {
57755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57756       };
57757     }
57758   }
57759 }
57760
57761
57762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57763   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57764   std::string *arg2 = 0 ;
57765   Dali::Actor arg3 ;
57766   Dali::Actor *argp3 ;
57767
57768   arg1 = (Dali::Toolkit::Builder *)jarg1;
57769   if (!jarg2) {
57770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57771     return ;
57772   }
57773   std::string arg2_str(jarg2);
57774   arg2 = &arg2_str;
57775   argp3 = (Dali::Actor *)jarg3;
57776   if (!argp3) {
57777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57778     return ;
57779   }
57780   arg3 = *argp3;
57781   {
57782     try {
57783       (arg1)->AddActors((std::string const &)*arg2,arg3);
57784     } catch (std::out_of_range& e) {
57785       {
57786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57787       };
57788     } catch (std::exception& e) {
57789       {
57790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57791       };
57792     } catch (...) {
57793       {
57794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57795       };
57796     }
57797   }
57798
57799   //argout typemap for const std::string&
57800
57801 }
57802
57803
57804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
57805   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57806   std::string *arg2 = 0 ;
57807
57808   arg1 = (Dali::Toolkit::Builder *)jarg1;
57809   if (!jarg2) {
57810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57811     return ;
57812   }
57813   std::string arg2_str(jarg2);
57814   arg2 = &arg2_str;
57815   {
57816     try {
57817       (arg1)->CreateRenderTask((std::string const &)*arg2);
57818     } catch (std::out_of_range& e) {
57819       {
57820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57821       };
57822     } catch (std::exception& e) {
57823       {
57824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57825       };
57826     } catch (...) {
57827       {
57828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57829       };
57830     }
57831   }
57832
57833   //argout typemap for const std::string&
57834
57835 }
57836
57837
57838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
57839   void * jresult ;
57840   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57841   std::string *arg2 = 0 ;
57842   Dali::FrameBufferImage result;
57843
57844   arg1 = (Dali::Toolkit::Builder *)jarg1;
57845   if (!jarg2) {
57846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57847     return 0;
57848   }
57849   std::string arg2_str(jarg2);
57850   arg2 = &arg2_str;
57851   {
57852     try {
57853       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
57854     } catch (std::out_of_range& e) {
57855       {
57856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57857       };
57858     } catch (std::exception& e) {
57859       {
57860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57861       };
57862     } catch (...) {
57863       {
57864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57865       };
57866     }
57867   }
57868   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
57869
57870   //argout typemap for const std::string&
57871
57872   return jresult;
57873 }
57874
57875
57876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
57877   void * jresult ;
57878   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57879   std::string *arg2 = 0 ;
57880   Dali::Path result;
57881
57882   arg1 = (Dali::Toolkit::Builder *)jarg1;
57883   if (!jarg2) {
57884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57885     return 0;
57886   }
57887   std::string arg2_str(jarg2);
57888   arg2 = &arg2_str;
57889   {
57890     try {
57891       result = (arg1)->GetPath((std::string const &)*arg2);
57892     } catch (std::out_of_range& e) {
57893       {
57894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57895       };
57896     } catch (std::exception& e) {
57897       {
57898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57899       };
57900     } catch (...) {
57901       {
57902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57903       };
57904     }
57905   }
57906   jresult = new Dali::Path((const Dali::Path &)result);
57907
57908   //argout typemap for const std::string&
57909
57910   return jresult;
57911 }
57912
57913
57914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
57915   void * jresult ;
57916   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57917   std::string *arg2 = 0 ;
57918   Dali::PathConstrainer result;
57919
57920   arg1 = (Dali::Toolkit::Builder *)jarg1;
57921   if (!jarg2) {
57922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57923     return 0;
57924   }
57925   std::string arg2_str(jarg2);
57926   arg2 = &arg2_str;
57927   {
57928     try {
57929       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
57930     } catch (std::out_of_range& e) {
57931       {
57932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57933       };
57934     } catch (std::exception& e) {
57935       {
57936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57937       };
57938     } catch (...) {
57939       {
57940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57941       };
57942     }
57943   }
57944   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
57945
57946   //argout typemap for const std::string&
57947
57948   return jresult;
57949 }
57950
57951
57952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
57953   void * jresult ;
57954   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57955   std::string *arg2 = 0 ;
57956   Dali::LinearConstrainer result;
57957
57958   arg1 = (Dali::Toolkit::Builder *)jarg1;
57959   if (!jarg2) {
57960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57961     return 0;
57962   }
57963   std::string arg2_str(jarg2);
57964   arg2 = &arg2_str;
57965   {
57966     try {
57967       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
57968     } catch (std::out_of_range& e) {
57969       {
57970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57971       };
57972     } catch (std::exception& e) {
57973       {
57974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57975       };
57976     } catch (...) {
57977       {
57978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57979       };
57980     }
57981   }
57982   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
57983
57984   //argout typemap for const std::string&
57985
57986   return jresult;
57987 }
57988
57989
57990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
57991   void * jresult ;
57992   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57993   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
57994
57995   arg1 = (Dali::Toolkit::Builder *)jarg1;
57996   {
57997     try {
57998       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
57999     } catch (std::out_of_range& e) {
58000       {
58001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58002       };
58003     } catch (std::exception& e) {
58004       {
58005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58006       };
58007     } catch (...) {
58008       {
58009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58010       };
58011     }
58012   }
58013   jresult = (void *)result;
58014   return jresult;
58015 }
58016
58017
58018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58019   void * jresult ;
58020   Dali::Toolkit::TransitionData *result = 0 ;
58021
58022   {
58023     try {
58024       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58025     } catch (std::out_of_range& e) {
58026       {
58027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58028       };
58029     } catch (std::exception& e) {
58030       {
58031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58032       };
58033     } catch (...) {
58034       {
58035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58036       };
58037     }
58038   }
58039   jresult = (void *)result;
58040   return jresult;
58041 }
58042
58043
58044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58045   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58046
58047   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58048   {
58049     try {
58050       delete arg1;
58051     } catch (std::out_of_range& e) {
58052       {
58053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58054       };
58055     } catch (std::exception& e) {
58056       {
58057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58058       };
58059     } catch (...) {
58060       {
58061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58062       };
58063     }
58064   }
58065 }
58066
58067
58068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58069   void * jresult ;
58070   Dali::Property::Map *arg1 = 0 ;
58071   Dali::Toolkit::TransitionData result;
58072
58073   arg1 = (Dali::Property::Map *)jarg1;
58074   if (!arg1) {
58075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58076     return 0;
58077   }
58078   {
58079     try {
58080       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58081     } catch (std::out_of_range& e) {
58082       {
58083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58084       };
58085     } catch (std::exception& e) {
58086       {
58087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58088       };
58089     } catch (...) {
58090       {
58091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58092       };
58093     }
58094   }
58095   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58096   return jresult;
58097 }
58098
58099
58100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58101   void * jresult ;
58102   Dali::Property::Array *arg1 = 0 ;
58103   Dali::Toolkit::TransitionData result;
58104
58105   arg1 = (Dali::Property::Array *)jarg1;
58106   if (!arg1) {
58107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58108     return 0;
58109   }
58110   {
58111     try {
58112       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58113     } catch (std::out_of_range& e) {
58114       {
58115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58116       };
58117     } catch (std::exception& e) {
58118       {
58119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58120       };
58121     } catch (...) {
58122       {
58123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58124       };
58125     }
58126   }
58127   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58128   return jresult;
58129 }
58130
58131
58132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58133   void * jresult ;
58134   Dali::BaseHandle arg1 ;
58135   Dali::BaseHandle *argp1 ;
58136   Dali::Toolkit::TransitionData result;
58137
58138   argp1 = (Dali::BaseHandle *)jarg1;
58139   if (!argp1) {
58140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58141     return 0;
58142   }
58143   arg1 = *argp1;
58144   {
58145     try {
58146       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58147     } catch (std::out_of_range& e) {
58148       {
58149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58150       };
58151     } catch (std::exception& e) {
58152       {
58153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58154       };
58155     } catch (...) {
58156       {
58157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58158       };
58159     }
58160   }
58161   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58162   return jresult;
58163 }
58164
58165
58166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58167   void * jresult ;
58168   Dali::Toolkit::TransitionData *arg1 = 0 ;
58169   Dali::Toolkit::TransitionData *result = 0 ;
58170
58171   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58172   if (!arg1) {
58173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58174     return 0;
58175   }
58176   {
58177     try {
58178       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58179     } catch (std::out_of_range& e) {
58180       {
58181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58182       };
58183     } catch (std::exception& e) {
58184       {
58185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58186       };
58187     } catch (...) {
58188       {
58189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58190       };
58191     }
58192   }
58193   jresult = (void *)result;
58194   return jresult;
58195 }
58196
58197
58198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58199   void * jresult ;
58200   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58201   Dali::Toolkit::TransitionData *arg2 = 0 ;
58202   Dali::Toolkit::TransitionData *result = 0 ;
58203
58204   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58205   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58206   if (!arg2) {
58207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58208     return 0;
58209   }
58210   {
58211     try {
58212       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58213     } catch (std::out_of_range& e) {
58214       {
58215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58216       };
58217     } catch (std::exception& e) {
58218       {
58219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58220       };
58221     } catch (...) {
58222       {
58223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58224       };
58225     }
58226   }
58227   jresult = (void *)result;
58228   return jresult;
58229 }
58230
58231
58232 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58233   unsigned long jresult ;
58234   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58235   size_t result;
58236
58237   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58238   {
58239     try {
58240       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58241     } catch (std::out_of_range& e) {
58242       {
58243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58244       };
58245     } catch (std::exception& e) {
58246       {
58247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58248       };
58249     } catch (...) {
58250       {
58251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58252       };
58253     }
58254   }
58255   jresult = (unsigned long)result;
58256   return jresult;
58257 }
58258
58259
58260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58261   void * jresult ;
58262   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58263   size_t arg2 ;
58264   Dali::Property::Map result;
58265
58266   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58267   arg2 = (size_t)jarg2;
58268   {
58269     try {
58270       result = (arg1)->GetAnimatorAt(arg2);
58271     } catch (std::out_of_range& e) {
58272       {
58273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58274       };
58275     } catch (std::exception& e) {
58276       {
58277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58278       };
58279     } catch (...) {
58280       {
58281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58282       };
58283     }
58284   }
58285   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58286   return jresult;
58287 }
58288
58289
58290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
58291   void * jresult ;
58292   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
58293   Dali::Toolkit::TransitionData *result = 0 ;
58294
58295   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
58296   {
58297     try {
58298       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
58299     } catch (std::out_of_range& e) {
58300       {
58301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58302       };
58303     } catch (std::exception& e) {
58304       {
58305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58306       };
58307     } catch (...) {
58308       {
58309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58310       };
58311     }
58312   }
58313   jresult = (void *)result;
58314   return jresult;
58315 }
58316
58317
58318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58319   int jresult ;
58320   int result;
58321
58322   {
58323     try {
58324       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58325     } catch (std::out_of_range& e) {
58326       {
58327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58328       };
58329     } catch (std::exception& e) {
58330       {
58331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58332       };
58333     } catch (...) {
58334       {
58335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58336       };
58337     }
58338   }
58339   jresult = (int)result;
58340   return jresult;
58341 }
58342
58343
58344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58345   int jresult ;
58346   int result;
58347
58348   {
58349     try {
58350       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58351     } catch (std::out_of_range& e) {
58352       {
58353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58354       };
58355     } catch (std::exception& e) {
58356       {
58357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58358       };
58359     } catch (...) {
58360       {
58361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58362       };
58363     }
58364   }
58365   jresult = (int)result;
58366   return jresult;
58367 }
58368
58369
58370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58371   int jresult ;
58372   int result;
58373
58374   {
58375     try {
58376       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58377     } catch (std::out_of_range& e) {
58378       {
58379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58380       };
58381     } catch (std::exception& e) {
58382       {
58383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58384       };
58385     } catch (...) {
58386       {
58387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58388       };
58389     }
58390   }
58391   jresult = (int)result;
58392   return jresult;
58393 }
58394
58395
58396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58397   int jresult ;
58398   int result;
58399
58400   {
58401     try {
58402       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58403     } catch (std::out_of_range& e) {
58404       {
58405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58406       };
58407     } catch (std::exception& e) {
58408       {
58409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58410       };
58411     } catch (...) {
58412       {
58413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58414       };
58415     }
58416   }
58417   jresult = (int)result;
58418   return jresult;
58419 }
58420
58421
58422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58423   int jresult ;
58424   int result;
58425
58426   {
58427     try {
58428       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58429     } catch (std::out_of_range& e) {
58430       {
58431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58432       };
58433     } catch (std::exception& e) {
58434       {
58435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58436       };
58437     } catch (...) {
58438       {
58439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58440       };
58441     }
58442   }
58443   jresult = (int)result;
58444   return jresult;
58445 }
58446
58447
58448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58449   int jresult ;
58450   int result;
58451
58452   {
58453     try {
58454       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58455     } catch (std::out_of_range& e) {
58456       {
58457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58458       };
58459     } catch (std::exception& e) {
58460       {
58461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58462       };
58463     } catch (...) {
58464       {
58465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58466       };
58467     }
58468   }
58469   jresult = (int)result;
58470   return jresult;
58471 }
58472
58473
58474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58475   int jresult ;
58476   int result;
58477
58478   {
58479     try {
58480       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
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 (...) {
58490       {
58491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58492       };
58493     }
58494   }
58495   jresult = (int)result;
58496   return jresult;
58497 }
58498
58499
58500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58501   int jresult ;
58502   int result;
58503
58504   {
58505     try {
58506       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58507     } catch (std::out_of_range& e) {
58508       {
58509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58510       };
58511     } catch (std::exception& e) {
58512       {
58513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58514       };
58515     } catch (...) {
58516       {
58517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58518       };
58519     }
58520   }
58521   jresult = (int)result;
58522   return jresult;
58523 }
58524
58525
58526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58527   int jresult ;
58528   int result;
58529
58530   {
58531     try {
58532       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58533     } catch (std::out_of_range& e) {
58534       {
58535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58536       };
58537     } catch (std::exception& e) {
58538       {
58539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58540       };
58541     } catch (...) {
58542       {
58543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58544       };
58545     }
58546   }
58547   jresult = (int)result;
58548   return jresult;
58549 }
58550
58551
58552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58553   int jresult ;
58554   int result;
58555
58556   {
58557     try {
58558       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58559     } catch (std::out_of_range& e) {
58560       {
58561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58562       };
58563     } catch (std::exception& e) {
58564       {
58565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58566       };
58567     } catch (...) {
58568       {
58569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58570       };
58571     }
58572   }
58573   jresult = (int)result;
58574   return jresult;
58575 }
58576
58577
58578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58579   int jresult ;
58580   int result;
58581
58582   {
58583     try {
58584       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58585     } catch (std::out_of_range& e) {
58586       {
58587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58588       };
58589     } catch (std::exception& e) {
58590       {
58591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58592       };
58593     } catch (...) {
58594       {
58595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58596       };
58597     }
58598   }
58599   jresult = (int)result;
58600   return jresult;
58601 }
58602
58603
58604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58605   int jresult ;
58606   int result;
58607
58608   {
58609     try {
58610       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58611     } catch (std::out_of_range& e) {
58612       {
58613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58614       };
58615     } catch (std::exception& e) {
58616       {
58617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58618       };
58619     } catch (...) {
58620       {
58621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58622       };
58623     }
58624   }
58625   jresult = (int)result;
58626   return jresult;
58627 }
58628
58629
58630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58631   int jresult ;
58632   int result;
58633
58634   {
58635     try {
58636       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58637     } catch (std::out_of_range& e) {
58638       {
58639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58640       };
58641     } catch (std::exception& e) {
58642       {
58643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58644       };
58645     } catch (...) {
58646       {
58647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58648       };
58649     }
58650   }
58651   jresult = (int)result;
58652   return jresult;
58653 }
58654
58655
58656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58657   int jresult ;
58658   int result;
58659
58660   {
58661     try {
58662       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
58663     } catch (std::out_of_range& e) {
58664       {
58665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58666       };
58667     } catch (std::exception& e) {
58668       {
58669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58670       };
58671     } catch (...) {
58672       {
58673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58674       };
58675     }
58676   }
58677   jresult = (int)result;
58678   return jresult;
58679 }
58680
58681
58682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
58683   void * jresult ;
58684   Dali::Toolkit::Control result;
58685
58686   {
58687     try {
58688       result = Dali::Toolkit::Internal::Control::New();
58689     } catch (std::out_of_range& e) {
58690       {
58691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58692       };
58693     } catch (std::exception& e) {
58694       {
58695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58696       };
58697     } catch (...) {
58698       {
58699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58700       };
58701     }
58702   }
58703   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58704   return jresult;
58705 }
58706
58707
58708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
58709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58710   std::string *arg2 = 0 ;
58711
58712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58713   if (!jarg2) {
58714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58715     return ;
58716   }
58717   std::string arg2_str(jarg2);
58718   arg2 = &arg2_str;
58719   {
58720     try {
58721       (arg1)->SetStyleName((std::string const &)*arg2);
58722     } catch (std::out_of_range& e) {
58723       {
58724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58725       };
58726     } catch (std::exception& e) {
58727       {
58728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58729       };
58730     } catch (...) {
58731       {
58732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58733       };
58734     }
58735   }
58736
58737   //argout typemap for const std::string&
58738
58739 }
58740
58741
58742 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
58743   char * jresult ;
58744   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58745   std::string *result = 0 ;
58746
58747   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58748   {
58749     try {
58750       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
58751     } catch (std::out_of_range& e) {
58752       {
58753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58754       };
58755     } catch (std::exception& e) {
58756       {
58757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58758       };
58759     } catch (...) {
58760       {
58761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58762       };
58763     }
58764   }
58765   jresult = SWIG_csharp_string_callback(result->c_str());
58766   return jresult;
58767 }
58768
58769
58770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
58771   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58772   Dali::Vector4 *arg2 = 0 ;
58773
58774   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58775   arg2 = (Dali::Vector4 *)jarg2;
58776   if (!arg2) {
58777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
58778     return ;
58779   }
58780   {
58781     try {
58782       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
58783     } catch (std::out_of_range& e) {
58784       {
58785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58786       };
58787     } catch (std::exception& e) {
58788       {
58789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58790       };
58791     } catch (...) {
58792       {
58793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58794       };
58795     }
58796   }
58797 }
58798
58799
58800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
58801   void * jresult ;
58802   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58803   Dali::Vector4 result;
58804
58805   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58806   {
58807     try {
58808       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
58809     } catch (std::out_of_range& e) {
58810       {
58811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58812       };
58813     } catch (std::exception& e) {
58814       {
58815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58816       };
58817     } catch (...) {
58818       {
58819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58820       };
58821     }
58822   }
58823   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
58824   return jresult;
58825 }
58826
58827
58828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
58829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58830   Dali::Image arg2 ;
58831   Dali::Image *argp2 ;
58832
58833   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58834   argp2 = (Dali::Image *)jarg2;
58835   if (!argp2) {
58836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
58837     return ;
58838   }
58839   arg2 = *argp2;
58840   {
58841     try {
58842       (arg1)->SetBackgroundImage(arg2);
58843     } catch (std::out_of_range& e) {
58844       {
58845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58846       };
58847     } catch (std::exception& e) {
58848       {
58849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58850       };
58851     } catch (...) {
58852       {
58853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58854       };
58855     }
58856   }
58857 }
58858
58859
58860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
58861   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58862   Dali::Property::Map *arg2 = 0 ;
58863
58864   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58865   arg2 = (Dali::Property::Map *)jarg2;
58866   if (!arg2) {
58867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58868     return ;
58869   }
58870   {
58871     try {
58872       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
58873     } catch (std::out_of_range& e) {
58874       {
58875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58876       };
58877     } catch (std::exception& e) {
58878       {
58879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58880       };
58881     } catch (...) {
58882       {
58883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58884       };
58885     }
58886   }
58887 }
58888
58889
58890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
58891   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58892
58893   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58894   {
58895     try {
58896       (arg1)->ClearBackground();
58897     } catch (std::out_of_range& e) {
58898       {
58899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58900       };
58901     } catch (std::exception& e) {
58902       {
58903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58904       };
58905     } catch (...) {
58906       {
58907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58908       };
58909     }
58910   }
58911 }
58912
58913
58914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
58915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58916   Dali::Gesture::Type arg2 ;
58917
58918   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58919   arg2 = (Dali::Gesture::Type)jarg2;
58920   {
58921     try {
58922       (arg1)->EnableGestureDetection(arg2);
58923     } catch (std::out_of_range& e) {
58924       {
58925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58926       };
58927     } catch (std::exception& e) {
58928       {
58929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58930       };
58931     } catch (...) {
58932       {
58933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58934       };
58935     }
58936   }
58937 }
58938
58939
58940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
58941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58942   Dali::Gesture::Type arg2 ;
58943
58944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58945   arg2 = (Dali::Gesture::Type)jarg2;
58946   {
58947     try {
58948       (arg1)->DisableGestureDetection(arg2);
58949     } catch (std::out_of_range& e) {
58950       {
58951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58952       };
58953     } catch (std::exception& e) {
58954       {
58955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58956       };
58957     } catch (...) {
58958       {
58959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58960       };
58961     }
58962   }
58963 }
58964
58965
58966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
58967   void * jresult ;
58968   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58969   Dali::PinchGestureDetector result;
58970
58971   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58972   {
58973     try {
58974       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
58975     } catch (std::out_of_range& e) {
58976       {
58977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58978       };
58979     } catch (std::exception& e) {
58980       {
58981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58982       };
58983     } catch (...) {
58984       {
58985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58986       };
58987     }
58988   }
58989   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
58990   return jresult;
58991 }
58992
58993
58994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
58995   void * jresult ;
58996   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58997   Dali::PanGestureDetector result;
58998
58999   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59000   {
59001     try {
59002       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59003     } catch (std::out_of_range& e) {
59004       {
59005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59006       };
59007     } catch (std::exception& e) {
59008       {
59009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59010       };
59011     } catch (...) {
59012       {
59013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59014       };
59015     }
59016   }
59017   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59018   return jresult;
59019 }
59020
59021
59022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59023   void * jresult ;
59024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59025   Dali::TapGestureDetector result;
59026
59027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59028   {
59029     try {
59030       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59031     } catch (std::out_of_range& e) {
59032       {
59033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59034       };
59035     } catch (std::exception& e) {
59036       {
59037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59038       };
59039     } catch (...) {
59040       {
59041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59042       };
59043     }
59044   }
59045   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59046   return jresult;
59047 }
59048
59049
59050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59051   void * jresult ;
59052   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59053   Dali::LongPressGestureDetector result;
59054
59055   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59056   {
59057     try {
59058       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59059     } catch (std::out_of_range& e) {
59060       {
59061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59062       };
59063     } catch (std::exception& e) {
59064       {
59065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59066       };
59067     } catch (...) {
59068       {
59069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59070       };
59071     }
59072   }
59073   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59074   return jresult;
59075 }
59076
59077
59078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59080   bool arg2 ;
59081
59082   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59083   arg2 = jarg2 ? true : false;
59084   {
59085     try {
59086       (arg1)->SetKeyboardNavigationSupport(arg2);
59087     } catch (std::out_of_range& e) {
59088       {
59089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59090       };
59091     } catch (std::exception& e) {
59092       {
59093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59094       };
59095     } catch (...) {
59096       {
59097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59098       };
59099     }
59100   }
59101 }
59102
59103
59104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59105   unsigned int jresult ;
59106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59107   bool result;
59108
59109   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59110   {
59111     try {
59112       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59113     } catch (std::out_of_range& e) {
59114       {
59115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59116       };
59117     } catch (std::exception& e) {
59118       {
59119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59120       };
59121     } catch (...) {
59122       {
59123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59124       };
59125     }
59126   }
59127   jresult = result;
59128   return jresult;
59129 }
59130
59131
59132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59133   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59134
59135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59136   {
59137     try {
59138       (arg1)->SetKeyInputFocus();
59139     } catch (std::out_of_range& e) {
59140       {
59141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59142       };
59143     } catch (std::exception& e) {
59144       {
59145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59146       };
59147     } catch (...) {
59148       {
59149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59150       };
59151     }
59152   }
59153 }
59154
59155
59156 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59157   unsigned int jresult ;
59158   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59159   bool result;
59160
59161   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59162   {
59163     try {
59164       result = (bool)(arg1)->HasKeyInputFocus();
59165     } catch (std::out_of_range& e) {
59166       {
59167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59168       };
59169     } catch (std::exception& e) {
59170       {
59171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59172       };
59173     } catch (...) {
59174       {
59175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59176       };
59177     }
59178   }
59179   jresult = result;
59180   return jresult;
59181 }
59182
59183
59184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59185   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59186
59187   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59188   {
59189     try {
59190       (arg1)->ClearKeyInputFocus();
59191     } catch (std::out_of_range& e) {
59192       {
59193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59194       };
59195     } catch (std::exception& e) {
59196       {
59197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59198       };
59199     } catch (...) {
59200       {
59201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59202       };
59203     }
59204   }
59205 }
59206
59207
59208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59210   bool arg2 ;
59211
59212   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59213   arg2 = jarg2 ? true : false;
59214   {
59215     try {
59216       (arg1)->SetAsKeyboardFocusGroup(arg2);
59217     } catch (std::out_of_range& e) {
59218       {
59219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59220       };
59221     } catch (std::exception& e) {
59222       {
59223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59224       };
59225     } catch (...) {
59226       {
59227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59228       };
59229     }
59230   }
59231 }
59232
59233
59234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59235   unsigned int jresult ;
59236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59237   bool result;
59238
59239   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59240   {
59241     try {
59242       result = (bool)(arg1)->IsKeyboardFocusGroup();
59243     } catch (std::out_of_range& e) {
59244       {
59245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59246       };
59247     } catch (std::exception& e) {
59248       {
59249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59250       };
59251     } catch (...) {
59252       {
59253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59254       };
59255     }
59256   }
59257   jresult = result;
59258   return jresult;
59259 }
59260
59261
59262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
59263   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59264
59265   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59266   {
59267     try {
59268       (arg1)->AccessibilityActivate();
59269     } catch (std::out_of_range& e) {
59270       {
59271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59272       };
59273     } catch (std::exception& e) {
59274       {
59275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59276       };
59277     } catch (...) {
59278       {
59279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59280       };
59281     }
59282   }
59283 }
59284
59285
59286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
59287   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59288
59289   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59290   {
59291     try {
59292       (arg1)->KeyboardEnter();
59293     } catch (std::out_of_range& e) {
59294       {
59295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59296       };
59297     } catch (std::exception& e) {
59298       {
59299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59300       };
59301     } catch (...) {
59302       {
59303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59304       };
59305     }
59306   }
59307 }
59308
59309
59310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59311   void * jresult ;
59312   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59313   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59314
59315   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59316   {
59317     try {
59318       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59319     } catch (std::out_of_range& e) {
59320       {
59321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59322       };
59323     } catch (std::exception& e) {
59324       {
59325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59326       };
59327     } catch (...) {
59328       {
59329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59330       };
59331     }
59332   }
59333   jresult = (void *)result;
59334   return jresult;
59335 }
59336
59337
59338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59339   void * jresult ;
59340   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59341   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59342
59343   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59344   {
59345     try {
59346       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59347     } catch (std::out_of_range& e) {
59348       {
59349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59350       };
59351     } catch (std::exception& e) {
59352       {
59353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59354       };
59355     } catch (...) {
59356       {
59357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59358       };
59359     }
59360   }
59361   jresult = (void *)result;
59362   return jresult;
59363 }
59364
59365
59366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59367   void * jresult ;
59368   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59369   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59370
59371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59372   {
59373     try {
59374       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59375     } catch (std::out_of_range& e) {
59376       {
59377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59378       };
59379     } catch (std::exception& e) {
59380       {
59381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59382       };
59383     } catch (...) {
59384       {
59385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59386       };
59387     }
59388   }
59389   jresult = (void *)result;
59390   return jresult;
59391 }
59392
59393
59394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
59395   unsigned int jresult ;
59396   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59397   Dali::KeyEvent *arg2 = 0 ;
59398   bool result;
59399
59400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59401   arg2 = (Dali::KeyEvent *)jarg2;
59402   if (!arg2) {
59403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59404     return 0;
59405   }
59406   {
59407     try {
59408       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
59409     } catch (std::out_of_range& e) {
59410       {
59411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59412       };
59413     } catch (std::exception& e) {
59414       {
59415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59416       };
59417     } catch (...) {
59418       {
59419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59420       };
59421     }
59422   }
59423   jresult = result;
59424   return jresult;
59425 }
59426
59427
59428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
59429   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59430   int arg2 ;
59431   SwigDirector_ViewImpl *darg = 0;
59432
59433   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59434   arg2 = (int)jarg2;
59435   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59436   {
59437     try {
59438       (darg)->OnStageConnection(arg2);
59439     } catch (std::out_of_range& e) {
59440       {
59441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59442       };
59443     } catch (std::exception& e) {
59444       {
59445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59446       };
59447     } catch (...) {
59448       {
59449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59450       };
59451     }
59452   }
59453 }
59454
59455
59456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59457   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59458   int arg2 ;
59459   SwigDirector_ViewImpl *darg = 0;
59460
59461   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59462   arg2 = (int)jarg2;
59463   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59464   {
59465     try {
59466       (darg)->OnStageConnectionSwigPublic(arg2);
59467     } catch (std::out_of_range& e) {
59468       {
59469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59470       };
59471     } catch (std::exception& e) {
59472       {
59473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59474       };
59475     } catch (...) {
59476       {
59477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59478       };
59479     }
59480   }
59481 }
59482
59483
59484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
59485   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59486   SwigDirector_ViewImpl *darg = 0;
59487
59488   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59489   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59490   {
59491     try {
59492       (darg)->OnStageDisconnection();
59493     } catch (std::out_of_range& e) {
59494       {
59495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59496       };
59497     } catch (std::exception& e) {
59498       {
59499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59500       };
59501     } catch (...) {
59502       {
59503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59504       };
59505     }
59506   }
59507 }
59508
59509
59510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
59511   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59512   SwigDirector_ViewImpl *darg = 0;
59513
59514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59515   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59516   {
59517     try {
59518       (darg)->OnStageDisconnectionSwigPublic();
59519     } catch (std::out_of_range& e) {
59520       {
59521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59522       };
59523     } catch (std::exception& e) {
59524       {
59525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59526       };
59527     } catch (...) {
59528       {
59529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59530       };
59531     }
59532   }
59533 }
59534
59535
59536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59538   Dali::Actor *arg2 = 0 ;
59539   SwigDirector_ViewImpl *darg = 0;
59540
59541   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59542   arg2 = (Dali::Actor *)jarg2;
59543   if (!arg2) {
59544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59545     return ;
59546   }
59547   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59548   {
59549     try {
59550       (darg)->OnChildAdd(*arg2);
59551     } catch (std::out_of_range& e) {
59552       {
59553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59554       };
59555     } catch (std::exception& e) {
59556       {
59557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59558       };
59559     } catch (...) {
59560       {
59561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59562       };
59563     }
59564   }
59565 }
59566
59567
59568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59570   Dali::Actor *arg2 = 0 ;
59571   SwigDirector_ViewImpl *darg = 0;
59572
59573   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59574   arg2 = (Dali::Actor *)jarg2;
59575   if (!arg2) {
59576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59577     return ;
59578   }
59579   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59580   {
59581     try {
59582       (darg)->OnChildAddSwigPublic(*arg2);
59583     } catch (std::out_of_range& e) {
59584       {
59585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59586       };
59587     } catch (std::exception& e) {
59588       {
59589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59590       };
59591     } catch (...) {
59592       {
59593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59594       };
59595     }
59596   }
59597 }
59598
59599
59600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
59601   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59602   Dali::Actor *arg2 = 0 ;
59603   SwigDirector_ViewImpl *darg = 0;
59604
59605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59606   arg2 = (Dali::Actor *)jarg2;
59607   if (!arg2) {
59608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59609     return ;
59610   }
59611   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59612   {
59613     try {
59614       (darg)->OnChildRemove(*arg2);
59615     } catch (std::out_of_range& e) {
59616       {
59617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59618       };
59619     } catch (std::exception& e) {
59620       {
59621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59622       };
59623     } catch (...) {
59624       {
59625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59626       };
59627     }
59628   }
59629 }
59630
59631
59632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59633   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59634   Dali::Actor *arg2 = 0 ;
59635   SwigDirector_ViewImpl *darg = 0;
59636
59637   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59638   arg2 = (Dali::Actor *)jarg2;
59639   if (!arg2) {
59640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59641     return ;
59642   }
59643   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59644   {
59645     try {
59646       (darg)->OnChildRemoveSwigPublic(*arg2);
59647     } catch (std::out_of_range& e) {
59648       {
59649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59650       };
59651     } catch (std::exception& e) {
59652       {
59653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59654       };
59655     } catch (...) {
59656       {
59657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59658       };
59659     }
59660   }
59661 }
59662
59663
59664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
59665   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59666   Dali::Property::Index arg2 ;
59667   Dali::Property::Value arg3 ;
59668   Dali::Property::Value *argp3 ;
59669   SwigDirector_ViewImpl *darg = 0;
59670
59671   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59672   arg2 = (Dali::Property::Index)jarg2;
59673   argp3 = (Dali::Property::Value *)jarg3;
59674   if (!argp3) {
59675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59676     return ;
59677   }
59678   arg3 = *argp3;
59679   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59680   {
59681     try {
59682       (darg)->OnPropertySet(arg2,arg3);
59683     } catch (std::out_of_range& e) {
59684       {
59685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59686       };
59687     } catch (std::exception& e) {
59688       {
59689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59690       };
59691     } catch (...) {
59692       {
59693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59694       };
59695     }
59696   }
59697 }
59698
59699
59700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
59701   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59702   Dali::Property::Index arg2 ;
59703   Dali::Property::Value arg3 ;
59704   Dali::Property::Value *argp3 ;
59705   SwigDirector_ViewImpl *darg = 0;
59706
59707   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59708   arg2 = (Dali::Property::Index)jarg2;
59709   argp3 = (Dali::Property::Value *)jarg3;
59710   if (!argp3) {
59711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
59712     return ;
59713   }
59714   arg3 = *argp3;
59715   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59716   {
59717     try {
59718       (darg)->OnPropertySetSwigPublic(arg2,arg3);
59719     } catch (std::out_of_range& e) {
59720       {
59721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59722       };
59723     } catch (std::exception& e) {
59724       {
59725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59726       };
59727     } catch (...) {
59728       {
59729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59730       };
59731     }
59732   }
59733 }
59734
59735
59736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
59737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59738   Dali::Vector3 *arg2 = 0 ;
59739   SwigDirector_ViewImpl *darg = 0;
59740
59741   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59742   arg2 = (Dali::Vector3 *)jarg2;
59743   if (!arg2) {
59744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59745     return ;
59746   }
59747   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59748   {
59749     try {
59750       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
59751     } catch (std::out_of_range& e) {
59752       {
59753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59754       };
59755     } catch (std::exception& e) {
59756       {
59757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59758       };
59759     } catch (...) {
59760       {
59761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59762       };
59763     }
59764   }
59765 }
59766
59767
59768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59770   Dali::Vector3 *arg2 = 0 ;
59771   SwigDirector_ViewImpl *darg = 0;
59772
59773   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59774   arg2 = (Dali::Vector3 *)jarg2;
59775   if (!arg2) {
59776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59777     return ;
59778   }
59779   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59780   {
59781     try {
59782       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
59783     } catch (std::out_of_range& e) {
59784       {
59785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59786       };
59787     } catch (std::exception& e) {
59788       {
59789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59790       };
59791     } catch (...) {
59792       {
59793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59794       };
59795     }
59796   }
59797 }
59798
59799
59800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
59801   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59802   Dali::Animation *arg2 = 0 ;
59803   Dali::Vector3 *arg3 = 0 ;
59804   SwigDirector_ViewImpl *darg = 0;
59805
59806   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59807   arg2 = (Dali::Animation *)jarg2;
59808   if (!arg2) {
59809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
59810     return ;
59811   }
59812   arg3 = (Dali::Vector3 *)jarg3;
59813   if (!arg3) {
59814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59815     return ;
59816   }
59817   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59818   {
59819     try {
59820       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
59821     } catch (std::out_of_range& e) {
59822       {
59823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59824       };
59825     } catch (std::exception& e) {
59826       {
59827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59828       };
59829     } catch (...) {
59830       {
59831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59832       };
59833     }
59834   }
59835 }
59836
59837
59838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
59839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59840   Dali::Animation *arg2 = 0 ;
59841   Dali::Vector3 *arg3 = 0 ;
59842   SwigDirector_ViewImpl *darg = 0;
59843
59844   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59845   arg2 = (Dali::Animation *)jarg2;
59846   if (!arg2) {
59847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
59848     return ;
59849   }
59850   arg3 = (Dali::Vector3 *)jarg3;
59851   if (!arg3) {
59852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
59853     return ;
59854   }
59855   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59856   {
59857     try {
59858       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
59859     } catch (std::out_of_range& e) {
59860       {
59861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59862       };
59863     } catch (std::exception& e) {
59864       {
59865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59866       };
59867     } catch (...) {
59868       {
59869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59870       };
59871     }
59872   }
59873 }
59874
59875
59876 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
59877   unsigned int jresult ;
59878   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59879   Dali::TouchEvent *arg2 = 0 ;
59880   SwigDirector_ViewImpl *darg = 0;
59881   bool result;
59882
59883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59884   arg2 = (Dali::TouchEvent *)jarg2;
59885   if (!arg2) {
59886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
59887     return 0;
59888   }
59889   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59890   {
59891     try {
59892       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
59893     } catch (std::out_of_range& e) {
59894       {
59895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59896       };
59897     } catch (std::exception& e) {
59898       {
59899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59900       };
59901     } catch (...) {
59902       {
59903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59904       };
59905     }
59906   }
59907   jresult = result;
59908   return jresult;
59909 }
59910
59911
59912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59913   unsigned int jresult ;
59914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59915   Dali::TouchEvent *arg2 = 0 ;
59916   SwigDirector_ViewImpl *darg = 0;
59917   bool result;
59918
59919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59920   arg2 = (Dali::TouchEvent *)jarg2;
59921   if (!arg2) {
59922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
59923     return 0;
59924   }
59925   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59926   {
59927     try {
59928       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
59929     } catch (std::out_of_range& e) {
59930       {
59931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59932       };
59933     } catch (std::exception& e) {
59934       {
59935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59936       };
59937     } catch (...) {
59938       {
59939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59940       };
59941     }
59942   }
59943   jresult = result;
59944   return jresult;
59945 }
59946
59947
59948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
59949   unsigned int jresult ;
59950   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59951   Dali::HoverEvent *arg2 = 0 ;
59952   SwigDirector_ViewImpl *darg = 0;
59953   bool result;
59954
59955   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59956   arg2 = (Dali::HoverEvent *)jarg2;
59957   if (!arg2) {
59958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
59959     return 0;
59960   }
59961   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59962   {
59963     try {
59964       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
59965     } catch (std::out_of_range& e) {
59966       {
59967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59968       };
59969     } catch (std::exception& e) {
59970       {
59971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59972       };
59973     } catch (...) {
59974       {
59975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59976       };
59977     }
59978   }
59979   jresult = result;
59980   return jresult;
59981 }
59982
59983
59984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59985   unsigned int jresult ;
59986   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59987   Dali::HoverEvent *arg2 = 0 ;
59988   SwigDirector_ViewImpl *darg = 0;
59989   bool result;
59990
59991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59992   arg2 = (Dali::HoverEvent *)jarg2;
59993   if (!arg2) {
59994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
59995     return 0;
59996   }
59997   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59998   {
59999     try {
60000       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60001     } catch (std::out_of_range& e) {
60002       {
60003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60004       };
60005     } catch (std::exception& e) {
60006       {
60007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60008       };
60009     } catch (...) {
60010       {
60011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60012       };
60013     }
60014   }
60015   jresult = result;
60016   return jresult;
60017 }
60018
60019
60020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60021   unsigned int jresult ;
60022   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60023   Dali::KeyEvent *arg2 = 0 ;
60024   SwigDirector_ViewImpl *darg = 0;
60025   bool result;
60026
60027   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60028   arg2 = (Dali::KeyEvent *)jarg2;
60029   if (!arg2) {
60030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60031     return 0;
60032   }
60033   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60034   {
60035     try {
60036       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60037     } catch (std::out_of_range& e) {
60038       {
60039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60040       };
60041     } catch (std::exception& e) {
60042       {
60043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60044       };
60045     } catch (...) {
60046       {
60047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60048       };
60049     }
60050   }
60051   jresult = result;
60052   return jresult;
60053 }
60054
60055
60056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60057   unsigned int jresult ;
60058   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60059   Dali::KeyEvent *arg2 = 0 ;
60060   SwigDirector_ViewImpl *darg = 0;
60061   bool result;
60062
60063   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60064   arg2 = (Dali::KeyEvent *)jarg2;
60065   if (!arg2) {
60066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60067     return 0;
60068   }
60069   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60070   {
60071     try {
60072       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60073     } catch (std::out_of_range& e) {
60074       {
60075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60076       };
60077     } catch (std::exception& e) {
60078       {
60079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60080       };
60081     } catch (...) {
60082       {
60083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60084       };
60085     }
60086   }
60087   jresult = result;
60088   return jresult;
60089 }
60090
60091
60092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60093   unsigned int jresult ;
60094   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60095   Dali::WheelEvent *arg2 = 0 ;
60096   SwigDirector_ViewImpl *darg = 0;
60097   bool result;
60098
60099   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60100   arg2 = (Dali::WheelEvent *)jarg2;
60101   if (!arg2) {
60102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60103     return 0;
60104   }
60105   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60106   {
60107     try {
60108       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60109     } catch (std::out_of_range& e) {
60110       {
60111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60112       };
60113     } catch (std::exception& e) {
60114       {
60115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60116       };
60117     } catch (...) {
60118       {
60119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60120       };
60121     }
60122   }
60123   jresult = result;
60124   return jresult;
60125 }
60126
60127
60128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60129   unsigned int jresult ;
60130   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60131   Dali::WheelEvent *arg2 = 0 ;
60132   SwigDirector_ViewImpl *darg = 0;
60133   bool result;
60134
60135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60136   arg2 = (Dali::WheelEvent *)jarg2;
60137   if (!arg2) {
60138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60139     return 0;
60140   }
60141   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60142   {
60143     try {
60144       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
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 (...) {
60154       {
60155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60156       };
60157     }
60158   }
60159   jresult = result;
60160   return jresult;
60161 }
60162
60163
60164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60165   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60166   Dali::Vector2 *arg2 = 0 ;
60167   Dali::RelayoutContainer *arg3 = 0 ;
60168   SwigDirector_ViewImpl *darg = 0;
60169
60170   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60171   arg2 = (Dali::Vector2 *)jarg2;
60172   if (!arg2) {
60173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60174     return ;
60175   }
60176   arg3 = (Dali::RelayoutContainer *)jarg3;
60177   if (!arg3) {
60178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60179     return ;
60180   }
60181   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60182   {
60183     try {
60184       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60185     } catch (std::out_of_range& e) {
60186       {
60187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60188       };
60189     } catch (std::exception& e) {
60190       {
60191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60192       };
60193     } catch (...) {
60194       {
60195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60196       };
60197     }
60198   }
60199 }
60200
60201
60202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60204   Dali::Vector2 *arg2 = 0 ;
60205   Dali::RelayoutContainer *arg3 = 0 ;
60206   SwigDirector_ViewImpl *darg = 0;
60207
60208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60209   arg2 = (Dali::Vector2 *)jarg2;
60210   if (!arg2) {
60211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60212     return ;
60213   }
60214   arg3 = (Dali::RelayoutContainer *)jarg3;
60215   if (!arg3) {
60216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60217     return ;
60218   }
60219   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60220   {
60221     try {
60222       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60223     } catch (std::out_of_range& e) {
60224       {
60225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60226       };
60227     } catch (std::exception& e) {
60228       {
60229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60230       };
60231     } catch (...) {
60232       {
60233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60234       };
60235     }
60236   }
60237 }
60238
60239
60240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60242   Dali::ResizePolicy::Type arg2 ;
60243   Dali::Dimension::Type arg3 ;
60244   SwigDirector_ViewImpl *darg = 0;
60245
60246   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60247   arg2 = (Dali::ResizePolicy::Type)jarg2;
60248   arg3 = (Dali::Dimension::Type)jarg3;
60249   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60250   {
60251     try {
60252       (darg)->OnSetResizePolicy(arg2,arg3);
60253     } catch (std::out_of_range& e) {
60254       {
60255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60256       };
60257     } catch (std::exception& e) {
60258       {
60259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60260       };
60261     } catch (...) {
60262       {
60263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60264       };
60265     }
60266   }
60267 }
60268
60269
60270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60271   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60272   Dali::ResizePolicy::Type arg2 ;
60273   Dali::Dimension::Type arg3 ;
60274   SwigDirector_ViewImpl *darg = 0;
60275
60276   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60277   arg2 = (Dali::ResizePolicy::Type)jarg2;
60278   arg3 = (Dali::Dimension::Type)jarg3;
60279   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60280   {
60281     try {
60282       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60283     } catch (std::out_of_range& e) {
60284       {
60285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60286       };
60287     } catch (std::exception& e) {
60288       {
60289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60290       };
60291     } catch (...) {
60292       {
60293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60294       };
60295     }
60296   }
60297 }
60298
60299
60300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60301   void * jresult ;
60302   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60303   SwigDirector_ViewImpl *darg = 0;
60304   Dali::Vector3 result;
60305
60306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60307   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60308   {
60309     try {
60310       result = (darg)->GetNaturalSize();
60311     } catch (std::out_of_range& e) {
60312       {
60313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60314       };
60315     } catch (std::exception& e) {
60316       {
60317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60318       };
60319     } catch (...) {
60320       {
60321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60322       };
60323     }
60324   }
60325   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60326   return jresult;
60327 }
60328
60329
60330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60331   void * jresult ;
60332   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60333   SwigDirector_ViewImpl *darg = 0;
60334   Dali::Vector3 result;
60335
60336   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60337   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60338   {
60339     try {
60340       result = (darg)->GetNaturalSizeSwigPublic();
60341     } catch (std::out_of_range& e) {
60342       {
60343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60344       };
60345     } catch (std::exception& e) {
60346       {
60347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60348       };
60349     } catch (...) {
60350       {
60351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60352       };
60353     }
60354   }
60355   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60356   return jresult;
60357 }
60358
60359
60360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60361   float jresult ;
60362   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60363   Dali::Actor *arg2 = 0 ;
60364   Dali::Dimension::Type arg3 ;
60365   SwigDirector_ViewImpl *darg = 0;
60366   float result;
60367
60368   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60369   arg2 = (Dali::Actor *)jarg2;
60370   if (!arg2) {
60371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60372     return 0;
60373   }
60374   arg3 = (Dali::Dimension::Type)jarg3;
60375   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60376   {
60377     try {
60378       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60379     } catch (std::out_of_range& e) {
60380       {
60381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60382       };
60383     } catch (std::exception& e) {
60384       {
60385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60386       };
60387     } catch (...) {
60388       {
60389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60390       };
60391     }
60392   }
60393   jresult = result;
60394   return jresult;
60395 }
60396
60397
60398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60399   float jresult ;
60400   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60401   Dali::Actor *arg2 = 0 ;
60402   Dali::Dimension::Type arg3 ;
60403   SwigDirector_ViewImpl *darg = 0;
60404   float result;
60405
60406   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60407   arg2 = (Dali::Actor *)jarg2;
60408   if (!arg2) {
60409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60410     return 0;
60411   }
60412   arg3 = (Dali::Dimension::Type)jarg3;
60413   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60414   {
60415     try {
60416       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60417     } catch (std::out_of_range& e) {
60418       {
60419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60420       };
60421     } catch (std::exception& e) {
60422       {
60423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60424       };
60425     } catch (...) {
60426       {
60427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60428       };
60429     }
60430   }
60431   jresult = result;
60432   return jresult;
60433 }
60434
60435
60436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60437   float jresult ;
60438   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60439   float arg2 ;
60440   SwigDirector_ViewImpl *darg = 0;
60441   float result;
60442
60443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60444   arg2 = (float)jarg2;
60445   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60446   {
60447     try {
60448       result = (float)(darg)->GetHeightForWidth(arg2);
60449     } catch (std::out_of_range& e) {
60450       {
60451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60452       };
60453     } catch (std::exception& e) {
60454       {
60455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60456       };
60457     } catch (...) {
60458       {
60459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60460       };
60461     }
60462   }
60463   jresult = result;
60464   return jresult;
60465 }
60466
60467
60468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
60469   float jresult ;
60470   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60471   float arg2 ;
60472   SwigDirector_ViewImpl *darg = 0;
60473   float result;
60474
60475   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60476   arg2 = (float)jarg2;
60477   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60478   {
60479     try {
60480       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
60481     } catch (std::out_of_range& e) {
60482       {
60483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60484       };
60485     } catch (std::exception& e) {
60486       {
60487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60488       };
60489     } catch (...) {
60490       {
60491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60492       };
60493     }
60494   }
60495   jresult = result;
60496   return jresult;
60497 }
60498
60499
60500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
60501   float jresult ;
60502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60503   float arg2 ;
60504   SwigDirector_ViewImpl *darg = 0;
60505   float result;
60506
60507   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60508   arg2 = (float)jarg2;
60509   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60510   {
60511     try {
60512       result = (float)(darg)->GetWidthForHeight(arg2);
60513     } catch (std::out_of_range& e) {
60514       {
60515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60516       };
60517     } catch (std::exception& e) {
60518       {
60519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60520       };
60521     } catch (...) {
60522       {
60523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60524       };
60525     }
60526   }
60527   jresult = result;
60528   return jresult;
60529 }
60530
60531
60532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
60533   float jresult ;
60534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60535   float arg2 ;
60536   SwigDirector_ViewImpl *darg = 0;
60537   float result;
60538
60539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60540   arg2 = (float)jarg2;
60541   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60542   {
60543     try {
60544       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
60545     } catch (std::out_of_range& e) {
60546       {
60547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60548       };
60549     } catch (std::exception& e) {
60550       {
60551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60552       };
60553     } catch (...) {
60554       {
60555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60556       };
60557     }
60558   }
60559   jresult = result;
60560   return jresult;
60561 }
60562
60563
60564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
60565   unsigned int jresult ;
60566   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60567   Dali::Dimension::Type arg2 ;
60568   SwigDirector_ViewImpl *darg = 0;
60569   bool result;
60570
60571   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60572   arg2 = (Dali::Dimension::Type)jarg2;
60573   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60574   {
60575     try {
60576       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
60577     } catch (std::out_of_range& e) {
60578       {
60579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60580       };
60581     } catch (std::exception& e) {
60582       {
60583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60584       };
60585     } catch (...) {
60586       {
60587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60588       };
60589     }
60590   }
60591   jresult = result;
60592   return jresult;
60593 }
60594
60595
60596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
60597   unsigned int jresult ;
60598   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60599   Dali::Dimension::Type arg2 ;
60600   SwigDirector_ViewImpl *darg = 0;
60601   bool result;
60602
60603   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60604   arg2 = (Dali::Dimension::Type)jarg2;
60605   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60606   {
60607     try {
60608       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
60609     } catch (std::out_of_range& e) {
60610       {
60611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60612       };
60613     } catch (std::exception& e) {
60614       {
60615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60616       };
60617     } catch (...) {
60618       {
60619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60620       };
60621     }
60622   }
60623   jresult = result;
60624   return jresult;
60625 }
60626
60627
60628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
60629   unsigned int jresult ;
60630   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60631   SwigDirector_ViewImpl *darg = 0;
60632   bool result;
60633
60634   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60635   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60636   {
60637     try {
60638       result = (bool)(darg)->RelayoutDependentOnChildren();
60639     } catch (std::out_of_range& e) {
60640       {
60641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60642       };
60643     } catch (std::exception& e) {
60644       {
60645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60646       };
60647     } catch (...) {
60648       {
60649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60650       };
60651     }
60652   }
60653   jresult = result;
60654   return jresult;
60655 }
60656
60657
60658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
60659   unsigned int jresult ;
60660   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60661   SwigDirector_ViewImpl *darg = 0;
60662   bool result;
60663
60664   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60665   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60666   {
60667     try {
60668       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
60669     } catch (std::out_of_range& e) {
60670       {
60671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60672       };
60673     } catch (std::exception& e) {
60674       {
60675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60676       };
60677     } catch (...) {
60678       {
60679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60680       };
60681     }
60682   }
60683   jresult = result;
60684   return jresult;
60685 }
60686
60687
60688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
60689   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60690   Dali::Dimension::Type arg2 ;
60691   SwigDirector_ViewImpl *darg = 0;
60692
60693   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60694   arg2 = (Dali::Dimension::Type)jarg2;
60695   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60696   {
60697     try {
60698       (darg)->OnCalculateRelayoutSize(arg2);
60699     } catch (std::out_of_range& e) {
60700       {
60701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60702       };
60703     } catch (std::exception& e) {
60704       {
60705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60706       };
60707     } catch (...) {
60708       {
60709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60710       };
60711     }
60712   }
60713 }
60714
60715
60716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
60717   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60718   Dali::Dimension::Type arg2 ;
60719   SwigDirector_ViewImpl *darg = 0;
60720
60721   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60722   arg2 = (Dali::Dimension::Type)jarg2;
60723   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60724   {
60725     try {
60726       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
60727     } catch (std::out_of_range& e) {
60728       {
60729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60730       };
60731     } catch (std::exception& e) {
60732       {
60733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60734       };
60735     } catch (...) {
60736       {
60737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60738       };
60739     }
60740   }
60741 }
60742
60743
60744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
60745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60746   float arg2 ;
60747   Dali::Dimension::Type arg3 ;
60748   SwigDirector_ViewImpl *darg = 0;
60749
60750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60751   arg2 = (float)jarg2;
60752   arg3 = (Dali::Dimension::Type)jarg3;
60753   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60754   {
60755     try {
60756       (darg)->OnLayoutNegotiated(arg2,arg3);
60757     } catch (std::out_of_range& e) {
60758       {
60759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60760       };
60761     } catch (std::exception& e) {
60762       {
60763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60764       };
60765     } catch (...) {
60766       {
60767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60768       };
60769     }
60770   }
60771 }
60772
60773
60774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
60775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60776   float arg2 ;
60777   Dali::Dimension::Type arg3 ;
60778   SwigDirector_ViewImpl *darg = 0;
60779
60780   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60781   arg2 = (float)jarg2;
60782   arg3 = (Dali::Dimension::Type)jarg3;
60783   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60784   {
60785     try {
60786       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
60787     } catch (std::out_of_range& e) {
60788       {
60789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60790       };
60791     } catch (std::exception& e) {
60792       {
60793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60794       };
60795     } catch (...) {
60796       {
60797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60798       };
60799     }
60800   }
60801 }
60802
60803
60804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
60805   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60806
60807   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60808   {
60809     try {
60810       (arg1)->OnInitialize();
60811     } catch (std::out_of_range& e) {
60812       {
60813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60814       };
60815     } catch (std::exception& e) {
60816       {
60817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60818       };
60819     } catch (...) {
60820       {
60821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60822       };
60823     }
60824   }
60825 }
60826
60827
60828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
60829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60830
60831   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60832   {
60833     try {
60834       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
60835     } catch (std::out_of_range& e) {
60836       {
60837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60838       };
60839     } catch (std::exception& e) {
60840       {
60841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60842       };
60843     } catch (...) {
60844       {
60845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60846       };
60847     }
60848   }
60849 }
60850
60851
60852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
60853   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60854   Dali::Actor *arg2 = 0 ;
60855
60856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60857   arg2 = (Dali::Actor *)jarg2;
60858   if (!arg2) {
60859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60860     return ;
60861   }
60862   {
60863     try {
60864       (arg1)->OnControlChildAdd(*arg2);
60865     } catch (std::out_of_range& e) {
60866       {
60867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60868       };
60869     } catch (std::exception& e) {
60870       {
60871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60872       };
60873     } catch (...) {
60874       {
60875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60876       };
60877     }
60878   }
60879 }
60880
60881
60882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60884   Dali::Actor *arg2 = 0 ;
60885
60886   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60887   arg2 = (Dali::Actor *)jarg2;
60888   if (!arg2) {
60889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60890     return ;
60891   }
60892   {
60893     try {
60894       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
60895     } catch (std::out_of_range& e) {
60896       {
60897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60898       };
60899     } catch (std::exception& e) {
60900       {
60901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60902       };
60903     } catch (...) {
60904       {
60905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60906       };
60907     }
60908   }
60909 }
60910
60911
60912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
60913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60914   Dali::Actor *arg2 = 0 ;
60915
60916   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60917   arg2 = (Dali::Actor *)jarg2;
60918   if (!arg2) {
60919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60920     return ;
60921   }
60922   {
60923     try {
60924       (arg1)->OnControlChildRemove(*arg2);
60925     } catch (std::out_of_range& e) {
60926       {
60927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60928       };
60929     } catch (std::exception& e) {
60930       {
60931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60932       };
60933     } catch (...) {
60934       {
60935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60936       };
60937     }
60938   }
60939 }
60940
60941
60942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60943   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60944   Dali::Actor *arg2 = 0 ;
60945
60946   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60947   arg2 = (Dali::Actor *)jarg2;
60948   if (!arg2) {
60949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60950     return ;
60951   }
60952   {
60953     try {
60954       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
60955     } catch (std::out_of_range& e) {
60956       {
60957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60958       };
60959     } catch (std::exception& e) {
60960       {
60961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60962       };
60963     } catch (...) {
60964       {
60965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60966       };
60967     }
60968   }
60969 }
60970
60971
60972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
60973   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60974   Dali::Toolkit::StyleManager arg2 ;
60975   Dali::StyleChange::Type arg3 ;
60976   Dali::Toolkit::StyleManager *argp2 ;
60977
60978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60979   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
60980   if (!argp2) {
60981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
60982     return ;
60983   }
60984   arg2 = *argp2;
60985   arg3 = (Dali::StyleChange::Type)jarg3;
60986   {
60987     try {
60988       (arg1)->OnStyleChange(arg2,arg3);
60989     } catch (std::out_of_range& e) {
60990       {
60991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60992       };
60993     } catch (std::exception& e) {
60994       {
60995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60996       };
60997     } catch (...) {
60998       {
60999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61000       };
61001     }
61002   }
61003 }
61004
61005
61006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61007   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61008   Dali::Toolkit::StyleManager arg2 ;
61009   Dali::StyleChange::Type arg3 ;
61010   Dali::Toolkit::StyleManager *argp2 ;
61011
61012   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61013   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61014   if (!argp2) {
61015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61016     return ;
61017   }
61018   arg2 = *argp2;
61019   arg3 = (Dali::StyleChange::Type)jarg3;
61020   {
61021     try {
61022       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61023     } catch (std::out_of_range& e) {
61024       {
61025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61026       };
61027     } catch (std::exception& e) {
61028       {
61029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61030       };
61031     } catch (...) {
61032       {
61033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61034       };
61035     }
61036   }
61037 }
61038
61039
61040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61041   unsigned int jresult ;
61042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61043   bool result;
61044
61045   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61046   {
61047     try {
61048       result = (bool)(arg1)->OnAccessibilityActivated();
61049     } catch (std::out_of_range& e) {
61050       {
61051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61052       };
61053     } catch (std::exception& e) {
61054       {
61055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61056       };
61057     } catch (...) {
61058       {
61059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61060       };
61061     }
61062   }
61063   jresult = result;
61064   return jresult;
61065 }
61066
61067
61068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61069   unsigned int jresult ;
61070   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61071   bool result;
61072
61073   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61074   {
61075     try {
61076       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61077     } catch (std::out_of_range& e) {
61078       {
61079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61080       };
61081     } catch (std::exception& e) {
61082       {
61083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61084       };
61085     } catch (...) {
61086       {
61087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61088       };
61089     }
61090   }
61091   jresult = result;
61092   return jresult;
61093 }
61094
61095
61096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61097   unsigned int jresult ;
61098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61099   Dali::PanGesture arg2 ;
61100   Dali::PanGesture *argp2 ;
61101   bool result;
61102
61103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61104   argp2 = (Dali::PanGesture *)jarg2;
61105   if (!argp2) {
61106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61107     return 0;
61108   }
61109   arg2 = *argp2;
61110   {
61111     try {
61112       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61113     } catch (std::out_of_range& e) {
61114       {
61115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61116       };
61117     } catch (std::exception& e) {
61118       {
61119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61120       };
61121     } catch (...) {
61122       {
61123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61124       };
61125     }
61126   }
61127   jresult = result;
61128   return jresult;
61129 }
61130
61131
61132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61133   unsigned int jresult ;
61134   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61135   Dali::PanGesture arg2 ;
61136   Dali::PanGesture *argp2 ;
61137   bool result;
61138
61139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61140   argp2 = (Dali::PanGesture *)jarg2;
61141   if (!argp2) {
61142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61143     return 0;
61144   }
61145   arg2 = *argp2;
61146   {
61147     try {
61148       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61149     } catch (std::out_of_range& e) {
61150       {
61151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61152       };
61153     } catch (std::exception& e) {
61154       {
61155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61156       };
61157     } catch (...) {
61158       {
61159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61160       };
61161     }
61162   }
61163   jresult = result;
61164   return jresult;
61165 }
61166
61167
61168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61169   unsigned int jresult ;
61170   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61171   Dali::TouchEvent *arg2 = 0 ;
61172   bool result;
61173
61174   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61175   arg2 = (Dali::TouchEvent *)jarg2;
61176   if (!arg2) {
61177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61178     return 0;
61179   }
61180   {
61181     try {
61182       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61183     } catch (std::out_of_range& e) {
61184       {
61185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61186       };
61187     } catch (std::exception& e) {
61188       {
61189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61190       };
61191     } catch (...) {
61192       {
61193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61194       };
61195     }
61196   }
61197   jresult = result;
61198   return jresult;
61199 }
61200
61201
61202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61203   unsigned int jresult ;
61204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61205   Dali::TouchEvent *arg2 = 0 ;
61206   bool result;
61207
61208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61209   arg2 = (Dali::TouchEvent *)jarg2;
61210   if (!arg2) {
61211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61212     return 0;
61213   }
61214   {
61215     try {
61216       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61217     } catch (std::out_of_range& e) {
61218       {
61219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61220       };
61221     } catch (std::exception& e) {
61222       {
61223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61224       };
61225     } catch (...) {
61226       {
61227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61228       };
61229     }
61230   }
61231   jresult = result;
61232   return jresult;
61233 }
61234
61235
61236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61237   unsigned int jresult ;
61238   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61239   bool arg2 ;
61240   bool result;
61241
61242   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61243   arg2 = jarg2 ? true : false;
61244   {
61245     try {
61246       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61247     } catch (std::out_of_range& e) {
61248       {
61249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61250       };
61251     } catch (std::exception& e) {
61252       {
61253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61254       };
61255     } catch (...) {
61256       {
61257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61258       };
61259     }
61260   }
61261   jresult = result;
61262   return jresult;
61263 }
61264
61265
61266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61267   unsigned int jresult ;
61268   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61269   bool arg2 ;
61270   bool result;
61271
61272   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61273   arg2 = jarg2 ? true : false;
61274   {
61275     try {
61276       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61277     } catch (std::out_of_range& e) {
61278       {
61279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61280       };
61281     } catch (std::exception& e) {
61282       {
61283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61284       };
61285     } catch (...) {
61286       {
61287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61288       };
61289     }
61290   }
61291   jresult = result;
61292   return jresult;
61293 }
61294
61295
61296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61297   unsigned int jresult ;
61298   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61299   bool result;
61300
61301   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61302   {
61303     try {
61304       result = (bool)(arg1)->OnAccessibilityZoom();
61305     } catch (std::out_of_range& e) {
61306       {
61307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61308       };
61309     } catch (std::exception& e) {
61310       {
61311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61312       };
61313     } catch (...) {
61314       {
61315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61316       };
61317     }
61318   }
61319   jresult = result;
61320   return jresult;
61321 }
61322
61323
61324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61325   unsigned int jresult ;
61326   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61327   bool result;
61328
61329   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61330   {
61331     try {
61332       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61333     } catch (std::out_of_range& e) {
61334       {
61335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61336       };
61337     } catch (std::exception& e) {
61338       {
61339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61340       };
61341     } catch (...) {
61342       {
61343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61344       };
61345     }
61346   }
61347   jresult = result;
61348   return jresult;
61349 }
61350
61351
61352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61353   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61354
61355   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61356   {
61357     try {
61358       (arg1)->OnKeyInputFocusGained();
61359     } catch (std::out_of_range& e) {
61360       {
61361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61362       };
61363     } catch (std::exception& e) {
61364       {
61365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61366       };
61367     } catch (...) {
61368       {
61369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61370       };
61371     }
61372   }
61373 }
61374
61375
61376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61377   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61378
61379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61380   {
61381     try {
61382       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61383     } catch (std::out_of_range& e) {
61384       {
61385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61386       };
61387     } catch (std::exception& e) {
61388       {
61389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61390       };
61391     } catch (...) {
61392       {
61393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61394       };
61395     }
61396   }
61397 }
61398
61399
61400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61401   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61402
61403   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61404   {
61405     try {
61406       (arg1)->OnKeyInputFocusLost();
61407     } catch (std::out_of_range& e) {
61408       {
61409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61410       };
61411     } catch (std::exception& e) {
61412       {
61413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61414       };
61415     } catch (...) {
61416       {
61417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61418       };
61419     }
61420   }
61421 }
61422
61423
61424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61425   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61426
61427   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61428   {
61429     try {
61430       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61431     } catch (std::out_of_range& e) {
61432       {
61433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61434       };
61435     } catch (std::exception& e) {
61436       {
61437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61438       };
61439     } catch (...) {
61440       {
61441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61442       };
61443     }
61444   }
61445 }
61446
61447
61448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61449   void * jresult ;
61450   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61451   Dali::Actor arg2 ;
61452   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61453   bool arg4 ;
61454   Dali::Actor *argp2 ;
61455   Dali::Actor result;
61456
61457   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61458   argp2 = (Dali::Actor *)jarg2;
61459   if (!argp2) {
61460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61461     return 0;
61462   }
61463   arg2 = *argp2;
61464   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61465   arg4 = jarg4 ? true : false;
61466   {
61467     try {
61468       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61469     } catch (std::out_of_range& e) {
61470       {
61471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61472       };
61473     } catch (std::exception& e) {
61474       {
61475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61476       };
61477     } catch (...) {
61478       {
61479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61480       };
61481     }
61482   }
61483   jresult = new Dali::Actor((const Dali::Actor &)result);
61484   return jresult;
61485 }
61486
61487
61488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61489   void * jresult ;
61490   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61491   Dali::Actor arg2 ;
61492   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61493   bool arg4 ;
61494   Dali::Actor *argp2 ;
61495   Dali::Actor result;
61496
61497   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61498   argp2 = (Dali::Actor *)jarg2;
61499   if (!argp2) {
61500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61501     return 0;
61502   }
61503   arg2 = *argp2;
61504   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61505   arg4 = jarg4 ? true : false;
61506   {
61507     try {
61508       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61509     } catch (std::out_of_range& e) {
61510       {
61511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61512       };
61513     } catch (std::exception& e) {
61514       {
61515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61516       };
61517     } catch (...) {
61518       {
61519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61520       };
61521     }
61522   }
61523   jresult = new Dali::Actor((const Dali::Actor &)result);
61524   return jresult;
61525 }
61526
61527
61528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
61529   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61530   Dali::Actor arg2 ;
61531   Dali::Actor *argp2 ;
61532
61533   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61534   argp2 = (Dali::Actor *)jarg2;
61535   if (!argp2) {
61536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61537     return ;
61538   }
61539   arg2 = *argp2;
61540   {
61541     try {
61542       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
61543     } catch (std::out_of_range& e) {
61544       {
61545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61546       };
61547     } catch (std::exception& e) {
61548       {
61549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61550       };
61551     } catch (...) {
61552       {
61553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61554       };
61555     }
61556   }
61557 }
61558
61559
61560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61561   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61562   Dali::Actor arg2 ;
61563   Dali::Actor *argp2 ;
61564
61565   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61566   argp2 = (Dali::Actor *)jarg2;
61567   if (!argp2) {
61568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61569     return ;
61570   }
61571   arg2 = *argp2;
61572   {
61573     try {
61574       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
61575     } catch (std::out_of_range& e) {
61576       {
61577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61578       };
61579     } catch (std::exception& e) {
61580       {
61581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61582       };
61583     } catch (...) {
61584       {
61585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61586       };
61587     }
61588   }
61589 }
61590
61591
61592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
61593   unsigned int jresult ;
61594   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61595   bool result;
61596
61597   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61598   {
61599     try {
61600       result = (bool)(arg1)->OnKeyboardEnter();
61601     } catch (std::out_of_range& e) {
61602       {
61603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61604       };
61605     } catch (std::exception& e) {
61606       {
61607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61608       };
61609     } catch (...) {
61610       {
61611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61612       };
61613     }
61614   }
61615   jresult = result;
61616   return jresult;
61617 }
61618
61619
61620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
61621   unsigned int jresult ;
61622   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61623   bool result;
61624
61625   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61626   {
61627     try {
61628       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
61629     } catch (std::out_of_range& e) {
61630       {
61631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61632       };
61633     } catch (std::exception& e) {
61634       {
61635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61636       };
61637     } catch (...) {
61638       {
61639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61640       };
61641     }
61642   }
61643   jresult = result;
61644   return jresult;
61645 }
61646
61647
61648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
61649   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61650   Dali::PinchGesture *arg2 = 0 ;
61651
61652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61653   arg2 = (Dali::PinchGesture *)jarg2;
61654   if (!arg2) {
61655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61656     return ;
61657   }
61658   {
61659     try {
61660       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
61661     } catch (std::out_of_range& e) {
61662       {
61663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61664       };
61665     } catch (std::exception& e) {
61666       {
61667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61668       };
61669     } catch (...) {
61670       {
61671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61672       };
61673     }
61674   }
61675 }
61676
61677
61678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61679   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61680   Dali::PinchGesture *arg2 = 0 ;
61681
61682   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61683   arg2 = (Dali::PinchGesture *)jarg2;
61684   if (!arg2) {
61685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61686     return ;
61687   }
61688   {
61689     try {
61690       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
61691     } catch (std::out_of_range& e) {
61692       {
61693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61694       };
61695     } catch (std::exception& e) {
61696       {
61697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61698       };
61699     } catch (...) {
61700       {
61701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61702       };
61703     }
61704   }
61705 }
61706
61707
61708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
61709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61710   Dali::PanGesture *arg2 = 0 ;
61711
61712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61713   arg2 = (Dali::PanGesture *)jarg2;
61714   if (!arg2) {
61715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61716     return ;
61717   }
61718   {
61719     try {
61720       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
61721     } catch (std::out_of_range& e) {
61722       {
61723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61724       };
61725     } catch (std::exception& e) {
61726       {
61727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61728       };
61729     } catch (...) {
61730       {
61731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61732       };
61733     }
61734   }
61735 }
61736
61737
61738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61739   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61740   Dali::PanGesture *arg2 = 0 ;
61741
61742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61743   arg2 = (Dali::PanGesture *)jarg2;
61744   if (!arg2) {
61745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
61746     return ;
61747   }
61748   {
61749     try {
61750       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
61751     } catch (std::out_of_range& e) {
61752       {
61753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61754       };
61755     } catch (std::exception& e) {
61756       {
61757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61758       };
61759     } catch (...) {
61760       {
61761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61762       };
61763     }
61764   }
61765 }
61766
61767
61768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
61769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61770   Dali::TapGesture *arg2 = 0 ;
61771
61772   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61773   arg2 = (Dali::TapGesture *)jarg2;
61774   if (!arg2) {
61775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61776     return ;
61777   }
61778   {
61779     try {
61780       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
61781     } catch (std::out_of_range& e) {
61782       {
61783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61784       };
61785     } catch (std::exception& e) {
61786       {
61787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61788       };
61789     } catch (...) {
61790       {
61791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61792       };
61793     }
61794   }
61795 }
61796
61797
61798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61800   Dali::TapGesture *arg2 = 0 ;
61801
61802   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61803   arg2 = (Dali::TapGesture *)jarg2;
61804   if (!arg2) {
61805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
61806     return ;
61807   }
61808   {
61809     try {
61810       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
61811     } catch (std::out_of_range& e) {
61812       {
61813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61814       };
61815     } catch (std::exception& e) {
61816       {
61817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61818       };
61819     } catch (...) {
61820       {
61821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61822       };
61823     }
61824   }
61825 }
61826
61827
61828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
61829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61830   Dali::LongPressGesture *arg2 = 0 ;
61831
61832   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61833   arg2 = (Dali::LongPressGesture *)jarg2;
61834   if (!arg2) {
61835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
61836     return ;
61837   }
61838   {
61839     try {
61840       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
61841     } catch (std::out_of_range& e) {
61842       {
61843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61844       };
61845     } catch (std::exception& e) {
61846       {
61847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61848       };
61849     } catch (...) {
61850       {
61851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61852       };
61853     }
61854   }
61855 }
61856
61857
61858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61859   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61860   Dali::LongPressGesture *arg2 = 0 ;
61861
61862   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61863   arg2 = (Dali::LongPressGesture *)jarg2;
61864   if (!arg2) {
61865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
61866     return ;
61867   }
61868   {
61869     try {
61870       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
61871     } catch (std::out_of_range& e) {
61872       {
61873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61874       };
61875     } catch (std::exception& e) {
61876       {
61877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61878       };
61879     } catch (...) {
61880       {
61881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61882       };
61883     }
61884   }
61885 }
61886
61887
61888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
61889   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61890   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
61891   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
61892
61893   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61894   arg2 = (Dali::SlotObserver *)jarg2;
61895   arg3 = (Dali::CallbackBase *)jarg3;
61896   {
61897     try {
61898       (arg1)->SignalConnected(arg2,arg3);
61899     } catch (std::out_of_range& e) {
61900       {
61901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61902       };
61903     } catch (std::exception& e) {
61904       {
61905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61906       };
61907     } catch (...) {
61908       {
61909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61910       };
61911     }
61912   }
61913 }
61914
61915
61916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61917   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61918   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
61919   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
61920
61921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61922   arg2 = (Dali::SlotObserver *)jarg2;
61923   arg3 = (Dali::CallbackBase *)jarg3;
61924   {
61925     try {
61926       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
61927     } catch (std::out_of_range& e) {
61928       {
61929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61930       };
61931     } catch (std::exception& e) {
61932       {
61933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61934       };
61935     } catch (...) {
61936       {
61937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61938       };
61939     }
61940   }
61941 }
61942
61943
61944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
61945   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61946   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
61947   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
61948
61949   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61950   arg2 = (Dali::SlotObserver *)jarg2;
61951   arg3 = (Dali::CallbackBase *)jarg3;
61952   {
61953     try {
61954       (arg1)->SignalDisconnected(arg2,arg3);
61955     } catch (std::out_of_range& e) {
61956       {
61957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61958       };
61959     } catch (std::exception& e) {
61960       {
61961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61962       };
61963     } catch (...) {
61964       {
61965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61966       };
61967     }
61968   }
61969 }
61970
61971
61972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61973   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61974   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
61975   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
61976
61977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61978   arg2 = (Dali::SlotObserver *)jarg2;
61979   arg3 = (Dali::CallbackBase *)jarg3;
61980   {
61981     try {
61982       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
61983     } catch (std::out_of_range& e) {
61984       {
61985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61986       };
61987     } catch (std::exception& e) {
61988       {
61989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61990       };
61991     } catch (...) {
61992       {
61993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61994       };
61995     }
61996   }
61997 }
61998
61999
62000 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) {
62001   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62002   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62003   if (director) {
62004     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);
62005   }
62006 }
62007
62008
62009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62010   void * jresult ;
62011   Dali::Toolkit::Control *arg1 = 0 ;
62012   Dali::Toolkit::Internal::Control *result = 0 ;
62013
62014   arg1 = (Dali::Toolkit::Control *)jarg1;
62015   if (!arg1) {
62016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62017     return 0;
62018   }
62019   {
62020     try {
62021       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62022     } catch (std::out_of_range& e) {
62023       {
62024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62025       };
62026     } catch (std::exception& e) {
62027       {
62028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62029       };
62030     } catch (...) {
62031       {
62032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62033       };
62034     }
62035   }
62036   jresult = (void *)result;
62037   return jresult;
62038 }
62039
62040
62041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62042   int jresult ;
62043   int result;
62044
62045   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62046   jresult = (int)result;
62047   return jresult;
62048 }
62049
62050
62051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
62052   int jresult ;
62053   int result;
62054
62055   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
62056   jresult = (int)result;
62057   return jresult;
62058 }
62059
62060
62061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
62062   int jresult ;
62063   int result;
62064
62065   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
62066   jresult = (int)result;
62067   return jresult;
62068 }
62069
62070
62071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62072   int jresult ;
62073   int result;
62074
62075   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62076   jresult = (int)result;
62077   return jresult;
62078 }
62079
62080
62081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62082   int jresult ;
62083   int result;
62084
62085   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62086   jresult = (int)result;
62087   return jresult;
62088 }
62089
62090
62091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62092   void * jresult ;
62093   Dali::Toolkit::Control::Property *result = 0 ;
62094
62095   {
62096     try {
62097       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62098     } catch (std::out_of_range& e) {
62099       {
62100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62101       };
62102     } catch (std::exception& e) {
62103       {
62104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62105       };
62106     } catch (...) {
62107       {
62108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62109       };
62110     }
62111   }
62112   jresult = (void *)result;
62113   return jresult;
62114 }
62115
62116
62117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62118   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62119
62120   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62121   {
62122     try {
62123       delete arg1;
62124     } catch (std::out_of_range& e) {
62125       {
62126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62127       };
62128     } catch (std::exception& e) {
62129       {
62130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62131       };
62132     } catch (...) {
62133       {
62134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62135       };
62136     }
62137   }
62138 }
62139
62140
62141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62142   void * jresult ;
62143   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62144
62145   {
62146     try {
62147       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62148     } catch (std::out_of_range& e) {
62149       {
62150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62151       };
62152     } catch (std::exception& e) {
62153       {
62154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62155       };
62156     } catch (...) {
62157       {
62158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62159       };
62160     }
62161   }
62162   jresult = (void *)result;
62163   return jresult;
62164 }
62165
62166
62167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62168   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62169
62170   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62171   {
62172     try {
62173       delete arg1;
62174     } catch (std::out_of_range& e) {
62175       {
62176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62177       };
62178     } catch (std::exception& e) {
62179       {
62180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62181       };
62182     } catch (...) {
62183       {
62184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62185       };
62186     }
62187   }
62188 }
62189
62190
62191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62192   void * jresult ;
62193   Dali::Toolkit::Control result;
62194
62195   {
62196     try {
62197       result = Dali::Toolkit::Control::New();
62198     } catch (std::out_of_range& e) {
62199       {
62200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62201       };
62202     } catch (std::exception& e) {
62203       {
62204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62205       };
62206     } catch (...) {
62207       {
62208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62209       };
62210     }
62211   }
62212   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62213   return jresult;
62214 }
62215
62216
62217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62218   void * jresult ;
62219   Dali::Toolkit::Control *result = 0 ;
62220
62221   {
62222     try {
62223       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62224     } catch (std::out_of_range& e) {
62225       {
62226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62227       };
62228     } catch (std::exception& e) {
62229       {
62230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62231       };
62232     } catch (...) {
62233       {
62234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62235       };
62236     }
62237   }
62238   jresult = (void *)result;
62239   return jresult;
62240 }
62241
62242
62243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
62244   void * jresult ;
62245   Dali::Toolkit::Control *arg1 = 0 ;
62246   Dali::Toolkit::Control *result = 0 ;
62247
62248   arg1 = (Dali::Toolkit::Control *)jarg1;
62249   if (!arg1) {
62250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62251     return 0;
62252   }
62253   {
62254     try {
62255       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62256     } catch (std::out_of_range& e) {
62257       {
62258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62259       };
62260     } catch (std::exception& e) {
62261       {
62262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62263       };
62264     } catch (...) {
62265       {
62266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62267       };
62268     }
62269   }
62270   jresult = (void *)result;
62271   return jresult;
62272 }
62273
62274
62275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62276   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62277
62278   arg1 = (Dali::Toolkit::Control *)jarg1;
62279   {
62280     try {
62281       delete arg1;
62282     } catch (std::out_of_range& e) {
62283       {
62284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62285       };
62286     } catch (std::exception& e) {
62287       {
62288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62289       };
62290     } catch (...) {
62291       {
62292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62293       };
62294     }
62295   }
62296 }
62297
62298
62299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
62300   void * jresult ;
62301   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62302   Dali::Toolkit::Control *arg2 = 0 ;
62303   Dali::Toolkit::Control *result = 0 ;
62304
62305   arg1 = (Dali::Toolkit::Control *)jarg1;
62306   arg2 = (Dali::Toolkit::Control *)jarg2;
62307   if (!arg2) {
62308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62309     return 0;
62310   }
62311   {
62312     try {
62313       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
62314     } catch (std::out_of_range& e) {
62315       {
62316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62317       };
62318     } catch (std::exception& e) {
62319       {
62320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62321       };
62322     } catch (...) {
62323       {
62324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62325       };
62326     }
62327   }
62328   jresult = (void *)result;
62329   return jresult;
62330 }
62331
62332
62333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
62334   void * jresult ;
62335   Dali::BaseHandle arg1 ;
62336   Dali::BaseHandle *argp1 ;
62337   Dali::Toolkit::Control result;
62338
62339   argp1 = (Dali::BaseHandle *)jarg1;
62340   if (!argp1) {
62341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62342     return 0;
62343   }
62344   arg1 = *argp1;
62345   {
62346     try {
62347       result = Dali::Toolkit::Control::DownCast(arg1);
62348     } catch (std::out_of_range& e) {
62349       {
62350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62351       };
62352     } catch (std::exception& e) {
62353       {
62354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62355       };
62356     } catch (...) {
62357       {
62358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62359       };
62360     }
62361   }
62362   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62363   return jresult;
62364 }
62365
62366
62367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
62368   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62369
62370   arg1 = (Dali::Toolkit::Control *)jarg1;
62371   {
62372     try {
62373       (arg1)->SetKeyInputFocus();
62374     } catch (std::out_of_range& e) {
62375       {
62376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62377       };
62378     } catch (std::exception& e) {
62379       {
62380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62381       };
62382     } catch (...) {
62383       {
62384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62385       };
62386     }
62387   }
62388 }
62389
62390
62391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
62392   unsigned int jresult ;
62393   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62394   bool result;
62395
62396   arg1 = (Dali::Toolkit::Control *)jarg1;
62397   {
62398     try {
62399       result = (bool)(arg1)->HasKeyInputFocus();
62400     } catch (std::out_of_range& e) {
62401       {
62402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62403       };
62404     } catch (std::exception& e) {
62405       {
62406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62407       };
62408     } catch (...) {
62409       {
62410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62411       };
62412     }
62413   }
62414   jresult = result;
62415   return jresult;
62416 }
62417
62418
62419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
62420   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62421
62422   arg1 = (Dali::Toolkit::Control *)jarg1;
62423   {
62424     try {
62425       (arg1)->ClearKeyInputFocus();
62426     } catch (std::out_of_range& e) {
62427       {
62428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62429       };
62430     } catch (std::exception& e) {
62431       {
62432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62433       };
62434     } catch (...) {
62435       {
62436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62437       };
62438     }
62439   }
62440 }
62441
62442
62443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
62444   void * jresult ;
62445   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62446   Dali::PinchGestureDetector result;
62447
62448   arg1 = (Dali::Toolkit::Control *)jarg1;
62449   {
62450     try {
62451       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
62452     } catch (std::out_of_range& e) {
62453       {
62454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62455       };
62456     } catch (std::exception& e) {
62457       {
62458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62459       };
62460     } catch (...) {
62461       {
62462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62463       };
62464     }
62465   }
62466   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
62467   return jresult;
62468 }
62469
62470
62471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
62472   void * jresult ;
62473   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62474   Dali::PanGestureDetector result;
62475
62476   arg1 = (Dali::Toolkit::Control *)jarg1;
62477   {
62478     try {
62479       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
62480     } catch (std::out_of_range& e) {
62481       {
62482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62483       };
62484     } catch (std::exception& e) {
62485       {
62486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62487       };
62488     } catch (...) {
62489       {
62490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62491       };
62492     }
62493   }
62494   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
62495   return jresult;
62496 }
62497
62498
62499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
62500   void * jresult ;
62501   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62502   Dali::TapGestureDetector result;
62503
62504   arg1 = (Dali::Toolkit::Control *)jarg1;
62505   {
62506     try {
62507       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
62508     } catch (std::out_of_range& e) {
62509       {
62510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62511       };
62512     } catch (std::exception& e) {
62513       {
62514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62515       };
62516     } catch (...) {
62517       {
62518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62519       };
62520     }
62521   }
62522   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
62523   return jresult;
62524 }
62525
62526
62527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
62528   void * jresult ;
62529   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62530   Dali::LongPressGestureDetector result;
62531
62532   arg1 = (Dali::Toolkit::Control *)jarg1;
62533   {
62534     try {
62535       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
62536     } catch (std::out_of_range& e) {
62537       {
62538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62539       };
62540     } catch (std::exception& e) {
62541       {
62542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62543       };
62544     } catch (...) {
62545       {
62546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62547       };
62548     }
62549   }
62550   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
62551   return jresult;
62552 }
62553
62554
62555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
62556   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62557   std::string *arg2 = 0 ;
62558
62559   arg1 = (Dali::Toolkit::Control *)jarg1;
62560   if (!jarg2) {
62561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62562     return ;
62563   }
62564   std::string arg2_str(jarg2);
62565   arg2 = &arg2_str;
62566   {
62567     try {
62568       (arg1)->SetStyleName((std::string const &)*arg2);
62569     } catch (std::out_of_range& e) {
62570       {
62571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62572       };
62573     } catch (std::exception& e) {
62574       {
62575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62576       };
62577     } catch (...) {
62578       {
62579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62580       };
62581     }
62582   }
62583
62584   //argout typemap for const std::string&
62585
62586 }
62587
62588
62589 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
62590   char * jresult ;
62591   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62592   std::string *result = 0 ;
62593
62594   arg1 = (Dali::Toolkit::Control *)jarg1;
62595   {
62596     try {
62597       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
62598     } catch (std::out_of_range& e) {
62599       {
62600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62601       };
62602     } catch (std::exception& e) {
62603       {
62604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62605       };
62606     } catch (...) {
62607       {
62608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62609       };
62610     }
62611   }
62612   jresult = SWIG_csharp_string_callback(result->c_str());
62613   return jresult;
62614 }
62615
62616
62617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
62618   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62619   Dali::Vector4 *arg2 = 0 ;
62620
62621   arg1 = (Dali::Toolkit::Control *)jarg1;
62622   arg2 = (Dali::Vector4 *)jarg2;
62623   if (!arg2) {
62624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
62625     return ;
62626   }
62627   {
62628     try {
62629       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
62630     } catch (std::out_of_range& e) {
62631       {
62632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62633       };
62634     } catch (std::exception& e) {
62635       {
62636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62637       };
62638     } catch (...) {
62639       {
62640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62641       };
62642     }
62643   }
62644 }
62645
62646
62647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
62648   void * jresult ;
62649   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62650   Dali::Vector4 result;
62651
62652   arg1 = (Dali::Toolkit::Control *)jarg1;
62653   {
62654     try {
62655       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
62656     } catch (std::out_of_range& e) {
62657       {
62658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62659       };
62660     } catch (std::exception& e) {
62661       {
62662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62663       };
62664     } catch (...) {
62665       {
62666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62667       };
62668     }
62669   }
62670   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
62671   return jresult;
62672 }
62673
62674
62675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
62676   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62677   Dali::Image arg2 ;
62678   Dali::Image *argp2 ;
62679
62680   arg1 = (Dali::Toolkit::Control *)jarg1;
62681   argp2 = (Dali::Image *)jarg2;
62682   if (!argp2) {
62683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
62684     return ;
62685   }
62686   arg2 = *argp2;
62687   {
62688     try {
62689       (arg1)->SetBackgroundImage(arg2);
62690     } catch (std::out_of_range& e) {
62691       {
62692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62693       };
62694     } catch (std::exception& e) {
62695       {
62696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62697       };
62698     } catch (...) {
62699       {
62700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62701       };
62702     }
62703   }
62704 }
62705
62706
62707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
62708   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62709
62710   arg1 = (Dali::Toolkit::Control *)jarg1;
62711   {
62712     try {
62713       (arg1)->ClearBackground();
62714     } catch (std::out_of_range& e) {
62715       {
62716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62717       };
62718     } catch (std::exception& e) {
62719       {
62720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62721       };
62722     } catch (...) {
62723       {
62724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62725       };
62726     }
62727   }
62728 }
62729
62730
62731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
62732   void * jresult ;
62733   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62734   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
62735
62736   arg1 = (Dali::Toolkit::Control *)jarg1;
62737   {
62738     try {
62739       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
62740     } catch (std::out_of_range& e) {
62741       {
62742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62743       };
62744     } catch (std::exception& e) {
62745       {
62746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62747       };
62748     } catch (...) {
62749       {
62750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62751       };
62752     }
62753   }
62754   jresult = (void *)result;
62755   return jresult;
62756 }
62757
62758
62759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
62760   void * jresult ;
62761   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62762   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62763
62764   arg1 = (Dali::Toolkit::Control *)jarg1;
62765   {
62766     try {
62767       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
62768     } catch (std::out_of_range& e) {
62769       {
62770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62771       };
62772     } catch (std::exception& e) {
62773       {
62774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62775       };
62776     } catch (...) {
62777       {
62778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62779       };
62780     }
62781   }
62782   jresult = (void *)result;
62783   return jresult;
62784 }
62785
62786
62787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
62788   void * jresult ;
62789   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62790   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62791
62792   arg1 = (Dali::Toolkit::Control *)jarg1;
62793   {
62794     try {
62795       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
62796     } catch (std::out_of_range& e) {
62797       {
62798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62799       };
62800     } catch (std::exception& e) {
62801       {
62802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62803       };
62804     } catch (...) {
62805       {
62806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62807       };
62808     }
62809   }
62810   jresult = (void *)result;
62811   return jresult;
62812 }
62813
62814
62815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
62816   void * jresult ;
62817   Dali::Toolkit::Internal::Control *arg1 = 0 ;
62818   Dali::Toolkit::Control *result = 0 ;
62819
62820   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62821   if (!arg1) {
62822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
62823     return 0;
62824   }
62825   {
62826     try {
62827       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
62828     } catch (std::out_of_range& e) {
62829       {
62830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62831       };
62832     } catch (std::exception& e) {
62833       {
62834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62835       };
62836     } catch (...) {
62837       {
62838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62839       };
62840     }
62841   }
62842   jresult = (void *)result;
62843   return jresult;
62844 }
62845
62846
62847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
62848   void * jresult ;
62849   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
62850
62851   {
62852     try {
62853       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
62854     } catch (std::out_of_range& e) {
62855       {
62856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62857       };
62858     } catch (std::exception& e) {
62859       {
62860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62861       };
62862     } catch (...) {
62863       {
62864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62865       };
62866     }
62867   }
62868   jresult = (void *)result;
62869   return jresult;
62870 }
62871
62872
62873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
62874   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62875
62876   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62877   {
62878     try {
62879       delete arg1;
62880     } catch (std::out_of_range& e) {
62881       {
62882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62883       };
62884     } catch (std::exception& e) {
62885       {
62886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62887       };
62888     } catch (...) {
62889       {
62890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62891       };
62892     }
62893   }
62894 }
62895
62896
62897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
62898   void * jresult ;
62899   Dali::Toolkit::KeyInputFocusManager result;
62900
62901   {
62902     try {
62903       result = Dali::Toolkit::KeyInputFocusManager::Get();
62904     } catch (std::out_of_range& e) {
62905       {
62906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62907       };
62908     } catch (std::exception& e) {
62909       {
62910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62911       };
62912     } catch (...) {
62913       {
62914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62915       };
62916     }
62917   }
62918   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
62919   return jresult;
62920 }
62921
62922
62923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
62924   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62925   Dali::Toolkit::Control arg2 ;
62926   Dali::Toolkit::Control *argp2 ;
62927
62928   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62929   argp2 = (Dali::Toolkit::Control *)jarg2;
62930   if (!argp2) {
62931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
62932     return ;
62933   }
62934   arg2 = *argp2;
62935   {
62936     try {
62937       (arg1)->SetFocus(arg2);
62938     } catch (std::out_of_range& e) {
62939       {
62940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62941       };
62942     } catch (std::exception& e) {
62943       {
62944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62945       };
62946     } catch (...) {
62947       {
62948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62949       };
62950     }
62951   }
62952 }
62953
62954
62955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
62956   void * jresult ;
62957   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62958   Dali::Toolkit::Control result;
62959
62960   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62961   {
62962     try {
62963       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
62964     } catch (std::out_of_range& e) {
62965       {
62966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62967       };
62968     } catch (std::exception& e) {
62969       {
62970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62971       };
62972     } catch (...) {
62973       {
62974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62975       };
62976     }
62977   }
62978   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62979   return jresult;
62980 }
62981
62982
62983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
62984   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
62985   Dali::Toolkit::Control arg2 ;
62986   Dali::Toolkit::Control *argp2 ;
62987
62988   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
62989   argp2 = (Dali::Toolkit::Control *)jarg2;
62990   if (!argp2) {
62991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
62992     return ;
62993   }
62994   arg2 = *argp2;
62995   {
62996     try {
62997       (arg1)->RemoveFocus(arg2);
62998     } catch (std::out_of_range& e) {
62999       {
63000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63001       };
63002     } catch (std::exception& e) {
63003       {
63004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63005       };
63006     } catch (...) {
63007       {
63008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63009       };
63010     }
63011   }
63012 }
63013
63014
63015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_IsKeyboardListener(void * jarg1, void * jarg2) {
63016   unsigned int jresult ;
63017   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63018   Dali::Toolkit::Control arg2 ;
63019   Dali::Toolkit::Control *argp2 ;
63020   bool result;
63021
63022   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63023   argp2 = (Dali::Toolkit::Control *)jarg2;
63024   if (!argp2) {
63025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63026     return 0;
63027   }
63028   arg2 = *argp2;
63029   {
63030     try {
63031       result = (bool)(arg1)->IsKeyboardListener(arg2);
63032     } catch (std::out_of_range& e) {
63033       {
63034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63035       };
63036     } catch (std::exception& e) {
63037       {
63038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63039       };
63040     } catch (...) {
63041       {
63042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63043       };
63044     }
63045   }
63046   jresult = result;
63047   return jresult;
63048 }
63049
63050
63051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
63052   void * jresult ;
63053   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63054   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
63055
63056   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63057   {
63058     try {
63059       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
63060     } catch (std::out_of_range& e) {
63061       {
63062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63063       };
63064     } catch (std::exception& e) {
63065       {
63066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63067       };
63068     } catch (...) {
63069       {
63070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63071       };
63072     }
63073   }
63074   jresult = (void *)result;
63075   return jresult;
63076 }
63077
63078
63079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_UnhandledKeyEventSignal(void * jarg1) {
63080   void * jresult ;
63081   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63082   Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *result = 0 ;
63083
63084   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63085   {
63086     try {
63087       result = (Dali::Toolkit::KeyInputFocusManager::UnhandledKeyEventSignalType *) &(arg1)->UnhandledKeyEventSignal();
63088     } catch (std::out_of_range& e) {
63089       {
63090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63091       };
63092     } catch (std::exception& e) {
63093       {
63094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63095       };
63096     } catch (...) {
63097       {
63098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63099       };
63100     }
63101   }
63102   jresult = (void *)result;
63103   return jresult;
63104 }
63105
63106
63107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
63108   void * jresult ;
63109   Dali::Toolkit::Alignment::Padding *result = 0 ;
63110
63111   {
63112     try {
63113       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
63114     } catch (std::out_of_range& e) {
63115       {
63116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63117       };
63118     } catch (std::exception& e) {
63119       {
63120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63121       };
63122     } catch (...) {
63123       {
63124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63125       };
63126     }
63127   }
63128   jresult = (void *)result;
63129   return jresult;
63130 }
63131
63132
63133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
63134   void * jresult ;
63135   float arg1 ;
63136   float arg2 ;
63137   float arg3 ;
63138   float arg4 ;
63139   Dali::Toolkit::Alignment::Padding *result = 0 ;
63140
63141   arg1 = (float)jarg1;
63142   arg2 = (float)jarg2;
63143   arg3 = (float)jarg3;
63144   arg4 = (float)jarg4;
63145   {
63146     try {
63147       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
63148     } catch (std::out_of_range& e) {
63149       {
63150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63151       };
63152     } catch (std::exception& e) {
63153       {
63154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63155       };
63156     } catch (...) {
63157       {
63158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63159       };
63160     }
63161   }
63162   jresult = (void *)result;
63163   return jresult;
63164 }
63165
63166
63167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
63168   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63169   float arg2 ;
63170
63171   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63172   arg2 = (float)jarg2;
63173   if (arg1) (arg1)->left = arg2;
63174 }
63175
63176
63177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
63178   float jresult ;
63179   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63180   float result;
63181
63182   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63183   result = (float) ((arg1)->left);
63184   jresult = result;
63185   return jresult;
63186 }
63187
63188
63189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
63190   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63191   float arg2 ;
63192
63193   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63194   arg2 = (float)jarg2;
63195   if (arg1) (arg1)->right = arg2;
63196 }
63197
63198
63199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
63200   float jresult ;
63201   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63202   float result;
63203
63204   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63205   result = (float) ((arg1)->right);
63206   jresult = result;
63207   return jresult;
63208 }
63209
63210
63211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
63212   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63213   float arg2 ;
63214
63215   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63216   arg2 = (float)jarg2;
63217   if (arg1) (arg1)->top = arg2;
63218 }
63219
63220
63221 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
63222   float jresult ;
63223   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63224   float result;
63225
63226   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63227   result = (float) ((arg1)->top);
63228   jresult = result;
63229   return jresult;
63230 }
63231
63232
63233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
63234   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63235   float arg2 ;
63236
63237   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63238   arg2 = (float)jarg2;
63239   if (arg1) (arg1)->bottom = arg2;
63240 }
63241
63242
63243 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
63244   float jresult ;
63245   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63246   float result;
63247
63248   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63249   result = (float) ((arg1)->bottom);
63250   jresult = result;
63251   return jresult;
63252 }
63253
63254
63255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
63256   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63257
63258   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63259   {
63260     try {
63261       delete arg1;
63262     } catch (std::out_of_range& e) {
63263       {
63264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63265       };
63266     } catch (std::exception& e) {
63267       {
63268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63269       };
63270     } catch (...) {
63271       {
63272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63273       };
63274     }
63275   }
63276 }
63277
63278
63279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
63280   void * jresult ;
63281   Dali::Toolkit::Alignment *result = 0 ;
63282
63283   {
63284     try {
63285       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
63286     } catch (std::out_of_range& e) {
63287       {
63288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63289       };
63290     } catch (std::exception& e) {
63291       {
63292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63293       };
63294     } catch (...) {
63295       {
63296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63297       };
63298     }
63299   }
63300   jresult = (void *)result;
63301   return jresult;
63302 }
63303
63304
63305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
63306   void * jresult ;
63307   Dali::Toolkit::Alignment::Type arg1 ;
63308   Dali::Toolkit::Alignment::Type arg2 ;
63309   Dali::Toolkit::Alignment result;
63310
63311   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63312   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63313   {
63314     try {
63315       result = Dali::Toolkit::Alignment::New(arg1,arg2);
63316     } catch (std::out_of_range& e) {
63317       {
63318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63319       };
63320     } catch (std::exception& e) {
63321       {
63322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63323       };
63324     } catch (...) {
63325       {
63326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63327       };
63328     }
63329   }
63330   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63331   return jresult;
63332 }
63333
63334
63335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
63336   void * jresult ;
63337   Dali::Toolkit::Alignment::Type arg1 ;
63338   Dali::Toolkit::Alignment result;
63339
63340   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63341   {
63342     try {
63343       result = Dali::Toolkit::Alignment::New(arg1);
63344     } catch (std::out_of_range& e) {
63345       {
63346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63347       };
63348     } catch (std::exception& e) {
63349       {
63350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63351       };
63352     } catch (...) {
63353       {
63354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63355       };
63356     }
63357   }
63358   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63359   return jresult;
63360 }
63361
63362
63363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
63364   void * jresult ;
63365   Dali::Toolkit::Alignment result;
63366
63367   {
63368     try {
63369       result = Dali::Toolkit::Alignment::New();
63370     } catch (std::out_of_range& e) {
63371       {
63372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63373       };
63374     } catch (std::exception& e) {
63375       {
63376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63377       };
63378     } catch (...) {
63379       {
63380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63381       };
63382     }
63383   }
63384   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63385   return jresult;
63386 }
63387
63388
63389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
63390   void * jresult ;
63391   Dali::Toolkit::Alignment *arg1 = 0 ;
63392   Dali::Toolkit::Alignment *result = 0 ;
63393
63394   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63395   if (!arg1) {
63396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63397     return 0;
63398   }
63399   {
63400     try {
63401       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
63402     } catch (std::out_of_range& e) {
63403       {
63404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63405       };
63406     } catch (std::exception& e) {
63407       {
63408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63409       };
63410     } catch (...) {
63411       {
63412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63413       };
63414     }
63415   }
63416   jresult = (void *)result;
63417   return jresult;
63418 }
63419
63420
63421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
63422   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63423
63424   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63425   {
63426     try {
63427       delete arg1;
63428     } catch (std::out_of_range& e) {
63429       {
63430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63431       };
63432     } catch (std::exception& e) {
63433       {
63434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63435       };
63436     } catch (...) {
63437       {
63438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63439       };
63440     }
63441   }
63442 }
63443
63444
63445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
63446   void * jresult ;
63447   Dali::BaseHandle arg1 ;
63448   Dali::BaseHandle *argp1 ;
63449   Dali::Toolkit::Alignment result;
63450
63451   argp1 = (Dali::BaseHandle *)jarg1;
63452   if (!argp1) {
63453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63454     return 0;
63455   }
63456   arg1 = *argp1;
63457   {
63458     try {
63459       result = Dali::Toolkit::Alignment::DownCast(arg1);
63460     } catch (std::out_of_range& e) {
63461       {
63462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63463       };
63464     } catch (std::exception& e) {
63465       {
63466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63467       };
63468     } catch (...) {
63469       {
63470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63471       };
63472     }
63473   }
63474   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63475   return jresult;
63476 }
63477
63478
63479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
63480   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63481   Dali::Toolkit::Alignment::Type arg2 ;
63482
63483   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63484   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63485   {
63486     try {
63487       (arg1)->SetAlignmentType(arg2);
63488     } catch (std::out_of_range& e) {
63489       {
63490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63491       };
63492     } catch (std::exception& e) {
63493       {
63494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63495       };
63496     } catch (...) {
63497       {
63498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63499       };
63500     }
63501   }
63502 }
63503
63504
63505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
63506   int jresult ;
63507   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63508   Dali::Toolkit::Alignment::Type result;
63509
63510   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63511   {
63512     try {
63513       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
63514     } catch (std::out_of_range& e) {
63515       {
63516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63517       };
63518     } catch (std::exception& e) {
63519       {
63520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63521       };
63522     } catch (...) {
63523       {
63524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63525       };
63526     }
63527   }
63528   jresult = (int)result;
63529   return jresult;
63530 }
63531
63532
63533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
63534   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63535   Dali::Toolkit::Alignment::Scaling arg2 ;
63536
63537   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63538   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
63539   {
63540     try {
63541       (arg1)->SetScaling(arg2);
63542     } catch (std::out_of_range& e) {
63543       {
63544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63545       };
63546     } catch (std::exception& e) {
63547       {
63548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63549       };
63550     } catch (...) {
63551       {
63552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63553       };
63554     }
63555   }
63556 }
63557
63558
63559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
63560   int jresult ;
63561   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63562   Dali::Toolkit::Alignment::Scaling result;
63563
63564   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63565   {
63566     try {
63567       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
63568     } catch (std::out_of_range& e) {
63569       {
63570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63571       };
63572     } catch (std::exception& e) {
63573       {
63574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63575       };
63576     } catch (...) {
63577       {
63578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63579       };
63580     }
63581   }
63582   jresult = (int)result;
63583   return jresult;
63584 }
63585
63586
63587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
63588   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63589   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
63590
63591   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63592   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
63593   if (!arg2) {
63594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
63595     return ;
63596   }
63597   {
63598     try {
63599       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
63600     } catch (std::out_of_range& e) {
63601       {
63602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63603       };
63604     } catch (std::exception& e) {
63605       {
63606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63607       };
63608     } catch (...) {
63609       {
63610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63611       };
63612     }
63613   }
63614 }
63615
63616
63617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
63618   void * jresult ;
63619   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63620   Dali::Toolkit::Alignment::Padding *result = 0 ;
63621
63622   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63623   {
63624     try {
63625       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
63626     } catch (std::out_of_range& e) {
63627       {
63628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63629       };
63630     } catch (std::exception& e) {
63631       {
63632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63633       };
63634     } catch (...) {
63635       {
63636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63637       };
63638     }
63639   }
63640   jresult = (void *)result;
63641   return jresult;
63642 }
63643
63644
63645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
63646   void * jresult ;
63647   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63648   Dali::Toolkit::Alignment *arg2 = 0 ;
63649   Dali::Toolkit::Alignment *result = 0 ;
63650
63651   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63652   arg2 = (Dali::Toolkit::Alignment *)jarg2;
63653   if (!arg2) {
63654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63655     return 0;
63656   }
63657   {
63658     try {
63659       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
63660     } catch (std::out_of_range& e) {
63661       {
63662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63663       };
63664     } catch (std::exception& e) {
63665       {
63666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63667       };
63668     } catch (...) {
63669       {
63670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63671       };
63672     }
63673   }
63674   jresult = (void *)result;
63675   return jresult;
63676 }
63677
63678
63679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
63680   int jresult ;
63681   int result;
63682
63683   result = (int)Dali::Toolkit::Button::Property::DISABLED;
63684   jresult = (int)result;
63685   return jresult;
63686 }
63687
63688
63689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
63690   int jresult ;
63691   int result;
63692
63693   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
63694   jresult = (int)result;
63695   return jresult;
63696 }
63697
63698
63699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
63700   int jresult ;
63701   int result;
63702
63703   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
63704   jresult = (int)result;
63705   return jresult;
63706 }
63707
63708
63709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
63710   int jresult ;
63711   int result;
63712
63713   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
63714   jresult = (int)result;
63715   return jresult;
63716 }
63717
63718
63719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
63720   int jresult ;
63721   int result;
63722
63723   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
63724   jresult = (int)result;
63725   return jresult;
63726 }
63727
63728
63729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
63730   int jresult ;
63731   int result;
63732
63733   result = (int)Dali::Toolkit::Button::Property::SELECTED;
63734   jresult = (int)result;
63735   return jresult;
63736 }
63737
63738
63739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_STATE_IMAGE_get() {
63740   int jresult ;
63741   int result;
63742
63743   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_STATE_IMAGE;
63744   jresult = (int)result;
63745   return jresult;
63746 }
63747
63748
63749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_STATE_IMAGE_get() {
63750   int jresult ;
63751   int result;
63752
63753   result = (int)Dali::Toolkit::Button::Property::SELECTED_STATE_IMAGE;
63754   jresult = (int)result;
63755   return jresult;
63756 }
63757
63758
63759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_STATE_IMAGE_get() {
63760   int jresult ;
63761   int result;
63762
63763   result = (int)Dali::Toolkit::Button::Property::DISABLED_STATE_IMAGE;
63764   jresult = (int)result;
63765   return jresult;
63766 }
63767
63768
63769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
63770   int jresult ;
63771   int result;
63772
63773   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
63774   jresult = (int)result;
63775   return jresult;
63776 }
63777
63778
63779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
63780   int jresult ;
63781   int result;
63782
63783   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
63784   jresult = (int)result;
63785   return jresult;
63786 }
63787
63788
63789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
63790   int jresult ;
63791   int result;
63792
63793   result = (int)Dali::Toolkit::Button::Property::LABEL;
63794   jresult = (int)result;
63795   return jresult;
63796 }
63797
63798
63799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
63800   int jresult ;
63801   int result;
63802
63803   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
63804   jresult = (int)result;
63805   return jresult;
63806 }
63807
63808
63809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
63810   void * jresult ;
63811   Dali::Toolkit::Button::Property *result = 0 ;
63812
63813   {
63814     try {
63815       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
63816     } catch (std::out_of_range& e) {
63817       {
63818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63819       };
63820     } catch (std::exception& e) {
63821       {
63822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63823       };
63824     } catch (...) {
63825       {
63826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63827       };
63828     }
63829   }
63830   jresult = (void *)result;
63831   return jresult;
63832 }
63833
63834
63835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
63836   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
63837
63838   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
63839   {
63840     try {
63841       delete arg1;
63842     } catch (std::out_of_range& e) {
63843       {
63844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63845       };
63846     } catch (std::exception& e) {
63847       {
63848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63849       };
63850     } catch (...) {
63851       {
63852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63853       };
63854     }
63855   }
63856 }
63857
63858
63859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
63860   void * jresult ;
63861   Dali::Toolkit::Button *result = 0 ;
63862
63863   {
63864     try {
63865       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
63866     } catch (std::out_of_range& e) {
63867       {
63868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63869       };
63870     } catch (std::exception& e) {
63871       {
63872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63873       };
63874     } catch (...) {
63875       {
63876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63877       };
63878     }
63879   }
63880   jresult = (void *)result;
63881   return jresult;
63882 }
63883
63884
63885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
63886   void * jresult ;
63887   Dali::Toolkit::Button *arg1 = 0 ;
63888   Dali::Toolkit::Button *result = 0 ;
63889
63890   arg1 = (Dali::Toolkit::Button *)jarg1;
63891   if (!arg1) {
63892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
63893     return 0;
63894   }
63895   {
63896     try {
63897       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
63898     } catch (std::out_of_range& e) {
63899       {
63900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63901       };
63902     } catch (std::exception& e) {
63903       {
63904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63905       };
63906     } catch (...) {
63907       {
63908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63909       };
63910     }
63911   }
63912   jresult = (void *)result;
63913   return jresult;
63914 }
63915
63916
63917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
63918   void * jresult ;
63919   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63920   Dali::Toolkit::Button *arg2 = 0 ;
63921   Dali::Toolkit::Button *result = 0 ;
63922
63923   arg1 = (Dali::Toolkit::Button *)jarg1;
63924   arg2 = (Dali::Toolkit::Button *)jarg2;
63925   if (!arg2) {
63926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
63927     return 0;
63928   }
63929   {
63930     try {
63931       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
63932     } catch (std::out_of_range& e) {
63933       {
63934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63935       };
63936     } catch (std::exception& e) {
63937       {
63938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63939       };
63940     } catch (...) {
63941       {
63942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63943       };
63944     }
63945   }
63946   jresult = (void *)result;
63947   return jresult;
63948 }
63949
63950
63951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
63952   void * jresult ;
63953   Dali::BaseHandle arg1 ;
63954   Dali::BaseHandle *argp1 ;
63955   Dali::Toolkit::Button result;
63956
63957   argp1 = (Dali::BaseHandle *)jarg1;
63958   if (!argp1) {
63959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63960     return 0;
63961   }
63962   arg1 = *argp1;
63963   {
63964     try {
63965       result = Dali::Toolkit::Button::DownCast(arg1);
63966     } catch (std::out_of_range& e) {
63967       {
63968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63969       };
63970     } catch (std::exception& e) {
63971       {
63972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63973       };
63974     } catch (...) {
63975       {
63976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63977       };
63978     }
63979   }
63980   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
63981   return jresult;
63982 }
63983
63984
63985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
63986   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
63987
63988   arg1 = (Dali::Toolkit::Button *)jarg1;
63989   {
63990     try {
63991       delete arg1;
63992     } catch (std::out_of_range& e) {
63993       {
63994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63995       };
63996     } catch (std::exception& e) {
63997       {
63998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63999       };
64000     } catch (...) {
64001       {
64002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64003       };
64004     }
64005   }
64006 }
64007
64008
64009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
64010   unsigned int jresult ;
64011   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64012   bool result;
64013
64014   arg1 = (Dali::Toolkit::Button *)jarg1;
64015   {
64016     try {
64017       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
64018     } catch (std::out_of_range& e) {
64019       {
64020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64021       };
64022     } catch (std::exception& e) {
64023       {
64024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64025       };
64026     } catch (...) {
64027       {
64028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64029       };
64030     }
64031   }
64032   jresult = result;
64033   return jresult;
64034 }
64035
64036
64037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
64038   unsigned int jresult ;
64039   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64040   bool result;
64041
64042   arg1 = (Dali::Toolkit::Button *)jarg1;
64043   {
64044     try {
64045       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
64046     } catch (std::out_of_range& e) {
64047       {
64048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64049       };
64050     } catch (std::exception& e) {
64051       {
64052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64053       };
64054     } catch (...) {
64055       {
64056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64057       };
64058     }
64059   }
64060   jresult = result;
64061   return jresult;
64062 }
64063
64064
64065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
64066   float jresult ;
64067   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64068   float result;
64069
64070   arg1 = (Dali::Toolkit::Button *)jarg1;
64071   {
64072     try {
64073       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
64074     } catch (std::out_of_range& e) {
64075       {
64076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64077       };
64078     } catch (std::exception& e) {
64079       {
64080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64081       };
64082     } catch (...) {
64083       {
64084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64085       };
64086     }
64087   }
64088   jresult = result;
64089   return jresult;
64090 }
64091
64092
64093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
64094   float jresult ;
64095   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64096   float result;
64097
64098   arg1 = (Dali::Toolkit::Button *)jarg1;
64099   {
64100     try {
64101       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
64102     } catch (std::out_of_range& e) {
64103       {
64104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64105       };
64106     } catch (std::exception& e) {
64107       {
64108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64109       };
64110     } catch (...) {
64111       {
64112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64113       };
64114     }
64115   }
64116   jresult = result;
64117   return jresult;
64118 }
64119
64120
64121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
64122   unsigned int jresult ;
64123   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64124   bool result;
64125
64126   arg1 = (Dali::Toolkit::Button *)jarg1;
64127   {
64128     try {
64129       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
64130     } catch (std::out_of_range& e) {
64131       {
64132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64133       };
64134     } catch (std::exception& e) {
64135       {
64136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64137       };
64138     } catch (...) {
64139       {
64140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64141       };
64142     }
64143   }
64144   jresult = result;
64145   return jresult;
64146 }
64147
64148
64149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
64150   unsigned int jresult ;
64151   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64152   bool result;
64153
64154   arg1 = (Dali::Toolkit::Button *)jarg1;
64155   {
64156     try {
64157       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
64158     } catch (std::out_of_range& e) {
64159       {
64160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64161       };
64162     } catch (std::exception& e) {
64163       {
64164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64165       };
64166     } catch (...) {
64167       {
64168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64169       };
64170     }
64171   }
64172   jresult = result;
64173   return jresult;
64174 }
64175
64176
64177 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
64178   float jresult ;
64179   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64180   float result;
64181
64182   arg1 = (Dali::Toolkit::Button *)jarg1;
64183   {
64184     try {
64185       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
64186     } catch (std::out_of_range& e) {
64187       {
64188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64189       };
64190     } catch (std::exception& e) {
64191       {
64192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64193       };
64194     } catch (...) {
64195       {
64196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64197       };
64198     }
64199   }
64200   jresult = result;
64201   return jresult;
64202 }
64203
64204
64205 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
64206   char * jresult ;
64207   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64208   std::string result;
64209
64210   arg1 = (Dali::Toolkit::Button *)jarg1;
64211   {
64212     try {
64213       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
64214     } catch (std::out_of_range& e) {
64215       {
64216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64217       };
64218     } catch (std::exception& e) {
64219       {
64220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64221       };
64222     } catch (...) {
64223       {
64224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64225       };
64226     }
64227   }
64228   jresult = SWIG_csharp_string_callback((&result)->c_str());
64229   return jresult;
64230 }
64231
64232
64233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
64234   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64235   Dali::Actor arg2 ;
64236   Dali::Actor *argp2 ;
64237
64238   arg1 = (Dali::Toolkit::Button *)jarg1;
64239   argp2 = (Dali::Actor *)jarg2;
64240   if (!argp2) {
64241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64242     return ;
64243   }
64244   arg2 = *argp2;
64245   {
64246     try {
64247       (arg1)->SetLabel(arg2);
64248     } catch (std::out_of_range& e) {
64249       {
64250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64251       };
64252     } catch (std::exception& e) {
64253       {
64254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64255       };
64256     } catch (...) {
64257       {
64258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64259       };
64260     }
64261   }
64262 }
64263
64264
64265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
64266   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64267   Dali::Image arg2 ;
64268   Dali::Image *argp2 ;
64269
64270   arg1 = (Dali::Toolkit::Button *)jarg1;
64271   argp2 = (Dali::Image *)jarg2;
64272   if (!argp2) {
64273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64274     return ;
64275   }
64276   arg2 = *argp2;
64277   {
64278     try {
64279       (arg1)->SetButtonImage(arg2);
64280     } catch (std::out_of_range& e) {
64281       {
64282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64283       };
64284     } catch (std::exception& e) {
64285       {
64286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64287       };
64288     } catch (...) {
64289       {
64290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64291       };
64292     }
64293   }
64294 }
64295
64296
64297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
64298   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64299   Dali::Image arg2 ;
64300   Dali::Image *argp2 ;
64301
64302   arg1 = (Dali::Toolkit::Button *)jarg1;
64303   argp2 = (Dali::Image *)jarg2;
64304   if (!argp2) {
64305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64306     return ;
64307   }
64308   arg2 = *argp2;
64309   {
64310     try {
64311       (arg1)->SetSelectedImage(arg2);
64312     } catch (std::out_of_range& e) {
64313       {
64314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64315       };
64316     } catch (std::exception& e) {
64317       {
64318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64319       };
64320     } catch (...) {
64321       {
64322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64323       };
64324     }
64325   }
64326 }
64327
64328
64329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
64330   void * jresult ;
64331   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64332   Dali::Actor result;
64333
64334   arg1 = (Dali::Toolkit::Button *)jarg1;
64335   {
64336     try {
64337       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
64338     } catch (std::out_of_range& e) {
64339       {
64340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64341       };
64342     } catch (std::exception& e) {
64343       {
64344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64345       };
64346     } catch (...) {
64347       {
64348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64349       };
64350     }
64351   }
64352   jresult = new Dali::Actor((const Dali::Actor &)result);
64353   return jresult;
64354 }
64355
64356
64357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
64358   void * jresult ;
64359   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64360   Dali::Actor result;
64361
64362   arg1 = (Dali::Toolkit::Button *)jarg1;
64363   {
64364     try {
64365       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
64366     } catch (std::out_of_range& e) {
64367       {
64368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64369       };
64370     } catch (std::exception& e) {
64371       {
64372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64373       };
64374     } catch (...) {
64375       {
64376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64377       };
64378     }
64379   }
64380   jresult = new Dali::Actor((const Dali::Actor &)result);
64381   return jresult;
64382 }
64383
64384
64385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64386   void * jresult ;
64387   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64388   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64389
64390   arg1 = (Dali::Toolkit::Button *)jarg1;
64391   {
64392     try {
64393       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64394     } catch (std::out_of_range& e) {
64395       {
64396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64397       };
64398     } catch (std::exception& e) {
64399       {
64400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64401       };
64402     } catch (...) {
64403       {
64404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64405       };
64406     }
64407   }
64408   jresult = (void *)result;
64409   return jresult;
64410 }
64411
64412
64413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64414   void * jresult ;
64415   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64416   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64417
64418   arg1 = (Dali::Toolkit::Button *)jarg1;
64419   {
64420     try {
64421       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
64422     } catch (std::out_of_range& e) {
64423       {
64424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64425       };
64426     } catch (std::exception& e) {
64427       {
64428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64429       };
64430     } catch (...) {
64431       {
64432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64433       };
64434     }
64435   }
64436   jresult = (void *)result;
64437   return jresult;
64438 }
64439
64440
64441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
64442   void * jresult ;
64443   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64444   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64445
64446   arg1 = (Dali::Toolkit::Button *)jarg1;
64447   {
64448     try {
64449       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
64450     } catch (std::out_of_range& e) {
64451       {
64452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64453       };
64454     } catch (std::exception& e) {
64455       {
64456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64457       };
64458     } catch (...) {
64459       {
64460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64461       };
64462     }
64463   }
64464   jresult = (void *)result;
64465   return jresult;
64466 }
64467
64468
64469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
64470   void * jresult ;
64471   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64472   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64473
64474   arg1 = (Dali::Toolkit::Button *)jarg1;
64475   {
64476     try {
64477       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
64478     } catch (std::out_of_range& e) {
64479       {
64480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64481       };
64482     } catch (std::exception& e) {
64483       {
64484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64485       };
64486     } catch (...) {
64487       {
64488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64489       };
64490     }
64491   }
64492   jresult = (void *)result;
64493   return jresult;
64494 }
64495
64496
64497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
64498   void * jresult ;
64499   Dali::Toolkit::CheckBoxButton *result = 0 ;
64500
64501   {
64502     try {
64503       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
64504     } catch (std::out_of_range& e) {
64505       {
64506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64507       };
64508     } catch (std::exception& e) {
64509       {
64510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64511       };
64512     } catch (...) {
64513       {
64514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64515       };
64516     }
64517   }
64518   jresult = (void *)result;
64519   return jresult;
64520 }
64521
64522
64523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
64524   void * jresult ;
64525   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
64526   Dali::Toolkit::CheckBoxButton *result = 0 ;
64527
64528   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64529   if (!arg1) {
64530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64531     return 0;
64532   }
64533   {
64534     try {
64535       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
64536     } catch (std::out_of_range& e) {
64537       {
64538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64539       };
64540     } catch (std::exception& e) {
64541       {
64542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64543       };
64544     } catch (...) {
64545       {
64546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64547       };
64548     }
64549   }
64550   jresult = (void *)result;
64551   return jresult;
64552 }
64553
64554
64555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
64556   void * jresult ;
64557   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64558   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
64559   Dali::Toolkit::CheckBoxButton *result = 0 ;
64560
64561   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64562   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
64563   if (!arg2) {
64564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64565     return 0;
64566   }
64567   {
64568     try {
64569       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
64570     } catch (std::out_of_range& e) {
64571       {
64572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64573       };
64574     } catch (std::exception& e) {
64575       {
64576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64577       };
64578     } catch (...) {
64579       {
64580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64581       };
64582     }
64583   }
64584   jresult = (void *)result;
64585   return jresult;
64586 }
64587
64588
64589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
64590   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64591
64592   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64593   {
64594     try {
64595       delete arg1;
64596     } catch (std::out_of_range& e) {
64597       {
64598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64599       };
64600     } catch (std::exception& e) {
64601       {
64602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64603       };
64604     } catch (...) {
64605       {
64606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64607       };
64608     }
64609   }
64610 }
64611
64612
64613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
64614   void * jresult ;
64615   Dali::Toolkit::CheckBoxButton result;
64616
64617   {
64618     try {
64619       result = Dali::Toolkit::CheckBoxButton::New();
64620     } catch (std::out_of_range& e) {
64621       {
64622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64623       };
64624     } catch (std::exception& e) {
64625       {
64626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64627       };
64628     } catch (...) {
64629       {
64630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64631       };
64632     }
64633   }
64634   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64635   return jresult;
64636 }
64637
64638
64639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
64640   void * jresult ;
64641   Dali::BaseHandle arg1 ;
64642   Dali::BaseHandle *argp1 ;
64643   Dali::Toolkit::CheckBoxButton result;
64644
64645   argp1 = (Dali::BaseHandle *)jarg1;
64646   if (!argp1) {
64647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64648     return 0;
64649   }
64650   arg1 = *argp1;
64651   {
64652     try {
64653       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
64654     } catch (std::out_of_range& e) {
64655       {
64656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64657       };
64658     } catch (std::exception& e) {
64659       {
64660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64661       };
64662     } catch (...) {
64663       {
64664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64665       };
64666     }
64667   }
64668   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64669   return jresult;
64670 }
64671
64672
64673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
64674   int jresult ;
64675   int result;
64676
64677   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
64678   jresult = (int)result;
64679   return jresult;
64680 }
64681
64682
64683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
64684   int jresult ;
64685   int result;
64686
64687   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
64688   jresult = (int)result;
64689   return jresult;
64690 }
64691
64692
64693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
64694   int jresult ;
64695   int result;
64696
64697   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
64698   jresult = (int)result;
64699   return jresult;
64700 }
64701
64702
64703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
64704   int jresult ;
64705   int result;
64706
64707   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
64708   jresult = (int)result;
64709   return jresult;
64710 }
64711
64712
64713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
64714   int jresult ;
64715   int result;
64716
64717   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
64718   jresult = (int)result;
64719   return jresult;
64720 }
64721
64722
64723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
64724   void * jresult ;
64725   Dali::Toolkit::PushButton::Property *result = 0 ;
64726
64727   {
64728     try {
64729       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
64730     } catch (std::out_of_range& e) {
64731       {
64732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64733       };
64734     } catch (std::exception& e) {
64735       {
64736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64737       };
64738     } catch (...) {
64739       {
64740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64741       };
64742     }
64743   }
64744   jresult = (void *)result;
64745   return jresult;
64746 }
64747
64748
64749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
64750   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
64751
64752   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
64753   {
64754     try {
64755       delete arg1;
64756     } catch (std::out_of_range& e) {
64757       {
64758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64759       };
64760     } catch (std::exception& e) {
64761       {
64762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64763       };
64764     } catch (...) {
64765       {
64766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64767       };
64768     }
64769   }
64770 }
64771
64772
64773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
64774   void * jresult ;
64775   Dali::Toolkit::PushButton *result = 0 ;
64776
64777   {
64778     try {
64779       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
64780     } catch (std::out_of_range& e) {
64781       {
64782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64783       };
64784     } catch (std::exception& e) {
64785       {
64786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64787       };
64788     } catch (...) {
64789       {
64790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64791       };
64792     }
64793   }
64794   jresult = (void *)result;
64795   return jresult;
64796 }
64797
64798
64799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
64800   void * jresult ;
64801   Dali::Toolkit::PushButton *arg1 = 0 ;
64802   Dali::Toolkit::PushButton *result = 0 ;
64803
64804   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64805   if (!arg1) {
64806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
64807     return 0;
64808   }
64809   {
64810     try {
64811       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
64812     } catch (std::out_of_range& e) {
64813       {
64814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64815       };
64816     } catch (std::exception& e) {
64817       {
64818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64819       };
64820     } catch (...) {
64821       {
64822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64823       };
64824     }
64825   }
64826   jresult = (void *)result;
64827   return jresult;
64828 }
64829
64830
64831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
64832   void * jresult ;
64833   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64834   Dali::Toolkit::PushButton *arg2 = 0 ;
64835   Dali::Toolkit::PushButton *result = 0 ;
64836
64837   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64838   arg2 = (Dali::Toolkit::PushButton *)jarg2;
64839   if (!arg2) {
64840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
64841     return 0;
64842   }
64843   {
64844     try {
64845       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
64846     } catch (std::out_of_range& e) {
64847       {
64848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64849       };
64850     } catch (std::exception& e) {
64851       {
64852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64853       };
64854     } catch (...) {
64855       {
64856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64857       };
64858     }
64859   }
64860   jresult = (void *)result;
64861   return jresult;
64862 }
64863
64864
64865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
64866   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64867
64868   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64869   {
64870     try {
64871       delete arg1;
64872     } catch (std::out_of_range& e) {
64873       {
64874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64875       };
64876     } catch (std::exception& e) {
64877       {
64878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64879       };
64880     } catch (...) {
64881       {
64882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64883       };
64884     }
64885   }
64886 }
64887
64888
64889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
64890   void * jresult ;
64891   Dali::Toolkit::PushButton result;
64892
64893   {
64894     try {
64895       result = Dali::Toolkit::PushButton::New();
64896     } catch (std::out_of_range& e) {
64897       {
64898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64899       };
64900     } catch (std::exception& e) {
64901       {
64902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64903       };
64904     } catch (...) {
64905       {
64906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64907       };
64908     }
64909   }
64910   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
64911   return jresult;
64912 }
64913
64914
64915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
64916   void * jresult ;
64917   Dali::BaseHandle arg1 ;
64918   Dali::BaseHandle *argp1 ;
64919   Dali::Toolkit::PushButton result;
64920
64921   argp1 = (Dali::BaseHandle *)jarg1;
64922   if (!argp1) {
64923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64924     return 0;
64925   }
64926   arg1 = *argp1;
64927   {
64928     try {
64929       result = Dali::Toolkit::PushButton::DownCast(arg1);
64930     } catch (std::out_of_range& e) {
64931       {
64932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64933       };
64934     } catch (std::exception& e) {
64935       {
64936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64937       };
64938     } catch (...) {
64939       {
64940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64941       };
64942     }
64943   }
64944   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
64945   return jresult;
64946 }
64947
64948
64949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
64950   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64951   Dali::Image arg2 ;
64952   Dali::Image *argp2 ;
64953
64954   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64955   argp2 = (Dali::Image *)jarg2;
64956   if (!argp2) {
64957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64958     return ;
64959   }
64960   arg2 = *argp2;
64961   {
64962     try {
64963       (arg1)->SetButtonImage(arg2);
64964     } catch (std::out_of_range& e) {
64965       {
64966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64967       };
64968     } catch (std::exception& e) {
64969       {
64970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64971       };
64972     } catch (...) {
64973       {
64974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64975       };
64976     }
64977   }
64978 }
64979
64980
64981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
64982   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
64983   Dali::Actor arg2 ;
64984   Dali::Actor *argp2 ;
64985
64986   arg1 = (Dali::Toolkit::PushButton *)jarg1;
64987   argp2 = (Dali::Actor *)jarg2;
64988   if (!argp2) {
64989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64990     return ;
64991   }
64992   arg2 = *argp2;
64993   {
64994     try {
64995       (arg1)->SetButtonImage(arg2);
64996     } catch (std::out_of_range& e) {
64997       {
64998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64999       };
65000     } catch (std::exception& e) {
65001       {
65002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65003       };
65004     } catch (...) {
65005       {
65006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65007       };
65008     }
65009   }
65010 }
65011
65012
65013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
65014   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65015   Dali::Actor arg2 ;
65016   Dali::Actor *argp2 ;
65017
65018   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65019   argp2 = (Dali::Actor *)jarg2;
65020   if (!argp2) {
65021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65022     return ;
65023   }
65024   arg2 = *argp2;
65025   {
65026     try {
65027       (arg1)->SetBackgroundImage(arg2);
65028     } catch (std::out_of_range& e) {
65029       {
65030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65031       };
65032     } catch (std::exception& e) {
65033       {
65034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65035       };
65036     } catch (...) {
65037       {
65038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65039       };
65040     }
65041   }
65042 }
65043
65044
65045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
65046   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65047   Dali::Image arg2 ;
65048   Dali::Image *argp2 ;
65049
65050   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65051   argp2 = (Dali::Image *)jarg2;
65052   if (!argp2) {
65053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65054     return ;
65055   }
65056   arg2 = *argp2;
65057   {
65058     try {
65059       (arg1)->SetSelectedImage(arg2);
65060     } catch (std::out_of_range& e) {
65061       {
65062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65063       };
65064     } catch (std::exception& e) {
65065       {
65066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65067       };
65068     } catch (...) {
65069       {
65070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65071       };
65072     }
65073   }
65074 }
65075
65076
65077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
65078   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65079   Dali::Actor arg2 ;
65080   Dali::Actor *argp2 ;
65081
65082   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65083   argp2 = (Dali::Actor *)jarg2;
65084   if (!argp2) {
65085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65086     return ;
65087   }
65088   arg2 = *argp2;
65089   {
65090     try {
65091       (arg1)->SetSelectedImage(arg2);
65092     } catch (std::out_of_range& e) {
65093       {
65094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65095       };
65096     } catch (std::exception& e) {
65097       {
65098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65099       };
65100     } catch (...) {
65101       {
65102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65103       };
65104     }
65105   }
65106 }
65107
65108
65109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
65110   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65111   Dali::Actor arg2 ;
65112   Dali::Actor *argp2 ;
65113
65114   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65115   argp2 = (Dali::Actor *)jarg2;
65116   if (!argp2) {
65117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65118     return ;
65119   }
65120   arg2 = *argp2;
65121   {
65122     try {
65123       (arg1)->SetSelectedBackgroundImage(arg2);
65124     } catch (std::out_of_range& e) {
65125       {
65126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65127       };
65128     } catch (std::exception& e) {
65129       {
65130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65131       };
65132     } catch (...) {
65133       {
65134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65135       };
65136     }
65137   }
65138 }
65139
65140
65141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
65142   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65143   Dali::Actor arg2 ;
65144   Dali::Actor *argp2 ;
65145
65146   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65147   argp2 = (Dali::Actor *)jarg2;
65148   if (!argp2) {
65149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65150     return ;
65151   }
65152   arg2 = *argp2;
65153   {
65154     try {
65155       (arg1)->SetDisabledBackgroundImage(arg2);
65156     } catch (std::out_of_range& e) {
65157       {
65158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65159       };
65160     } catch (std::exception& e) {
65161       {
65162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65163       };
65164     } catch (...) {
65165       {
65166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65167       };
65168     }
65169   }
65170 }
65171
65172
65173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
65174   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65175   Dali::Actor arg2 ;
65176   Dali::Actor *argp2 ;
65177
65178   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65179   argp2 = (Dali::Actor *)jarg2;
65180   if (!argp2) {
65181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65182     return ;
65183   }
65184   arg2 = *argp2;
65185   {
65186     try {
65187       (arg1)->SetDisabledImage(arg2);
65188     } catch (std::out_of_range& e) {
65189       {
65190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65191       };
65192     } catch (std::exception& e) {
65193       {
65194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65195       };
65196     } catch (...) {
65197       {
65198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65199       };
65200     }
65201   }
65202 }
65203
65204
65205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
65206   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65207   Dali::Actor arg2 ;
65208   Dali::Actor *argp2 ;
65209
65210   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65211   argp2 = (Dali::Actor *)jarg2;
65212   if (!argp2) {
65213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65214     return ;
65215   }
65216   arg2 = *argp2;
65217   {
65218     try {
65219       (arg1)->SetDisabledSelectedImage(arg2);
65220     } catch (std::out_of_range& e) {
65221       {
65222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65223       };
65224     } catch (std::exception& e) {
65225       {
65226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65227       };
65228     } catch (...) {
65229       {
65230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65231       };
65232     }
65233   }
65234 }
65235
65236
65237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65238   void * jresult ;
65239   Dali::Toolkit::RadioButton *result = 0 ;
65240
65241   {
65242     try {
65243       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65244     } catch (std::out_of_range& e) {
65245       {
65246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65247       };
65248     } catch (std::exception& e) {
65249       {
65250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65251       };
65252     } catch (...) {
65253       {
65254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65255       };
65256     }
65257   }
65258   jresult = (void *)result;
65259   return jresult;
65260 }
65261
65262
65263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65264   void * jresult ;
65265   Dali::Toolkit::RadioButton *arg1 = 0 ;
65266   Dali::Toolkit::RadioButton *result = 0 ;
65267
65268   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65269   if (!arg1) {
65270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65271     return 0;
65272   }
65273   {
65274     try {
65275       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65276     } catch (std::out_of_range& e) {
65277       {
65278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65279       };
65280     } catch (std::exception& e) {
65281       {
65282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65283       };
65284     } catch (...) {
65285       {
65286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65287       };
65288     }
65289   }
65290   jresult = (void *)result;
65291   return jresult;
65292 }
65293
65294
65295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65296   void * jresult ;
65297   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65298   Dali::Toolkit::RadioButton *arg2 = 0 ;
65299   Dali::Toolkit::RadioButton *result = 0 ;
65300
65301   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65302   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65303   if (!arg2) {
65304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65305     return 0;
65306   }
65307   {
65308     try {
65309       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65310     } catch (std::out_of_range& e) {
65311       {
65312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65313       };
65314     } catch (std::exception& e) {
65315       {
65316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65317       };
65318     } catch (...) {
65319       {
65320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65321       };
65322     }
65323   }
65324   jresult = (void *)result;
65325   return jresult;
65326 }
65327
65328
65329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65330   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65331
65332   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65333   {
65334     try {
65335       delete arg1;
65336     } catch (std::out_of_range& e) {
65337       {
65338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65339       };
65340     } catch (std::exception& e) {
65341       {
65342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65343       };
65344     } catch (...) {
65345       {
65346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65347       };
65348     }
65349   }
65350 }
65351
65352
65353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65354   void * jresult ;
65355   Dali::Toolkit::RadioButton result;
65356
65357   {
65358     try {
65359       result = Dali::Toolkit::RadioButton::New();
65360     } catch (std::out_of_range& e) {
65361       {
65362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65363       };
65364     } catch (std::exception& e) {
65365       {
65366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65367       };
65368     } catch (...) {
65369       {
65370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65371       };
65372     }
65373   }
65374   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65375   return jresult;
65376 }
65377
65378
65379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65380   void * jresult ;
65381   std::string *arg1 = 0 ;
65382   Dali::Toolkit::RadioButton result;
65383
65384   if (!jarg1) {
65385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65386     return 0;
65387   }
65388   std::string arg1_str(jarg1);
65389   arg1 = &arg1_str;
65390   {
65391     try {
65392       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65393     } catch (std::out_of_range& e) {
65394       {
65395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65396       };
65397     } catch (std::exception& e) {
65398       {
65399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65400       };
65401     } catch (...) {
65402       {
65403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65404       };
65405     }
65406   }
65407   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65408
65409   //argout typemap for const std::string&
65410
65411   return jresult;
65412 }
65413
65414
65415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65416   void * jresult ;
65417   Dali::BaseHandle arg1 ;
65418   Dali::BaseHandle *argp1 ;
65419   Dali::Toolkit::RadioButton result;
65420
65421   argp1 = (Dali::BaseHandle *)jarg1;
65422   if (!argp1) {
65423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65424     return 0;
65425   }
65426   arg1 = *argp1;
65427   {
65428     try {
65429       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65430     } catch (std::out_of_range& e) {
65431       {
65432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65433       };
65434     } catch (std::exception& e) {
65435       {
65436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65437       };
65438     } catch (...) {
65439       {
65440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65441       };
65442     }
65443   }
65444   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65445   return jresult;
65446 }
65447
65448
65449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65450   int jresult ;
65451   int result;
65452
65453   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65454   jresult = (int)result;
65455   return jresult;
65456 }
65457
65458
65459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65460   int jresult ;
65461   int result;
65462
65463   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65464   jresult = (int)result;
65465   return jresult;
65466 }
65467
65468
65469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65470   int jresult ;
65471   int result;
65472
65473   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65474   jresult = (int)result;
65475   return jresult;
65476 }
65477
65478
65479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65480   int jresult ;
65481   int result;
65482
65483   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65484   jresult = (int)result;
65485   return jresult;
65486 }
65487
65488
65489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65490   int jresult ;
65491   int result;
65492
65493   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65494   jresult = (int)result;
65495   return jresult;
65496 }
65497
65498
65499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65500   int jresult ;
65501   int result;
65502
65503   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65504   jresult = (int)result;
65505   return jresult;
65506 }
65507
65508
65509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65510   void * jresult ;
65511   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65512
65513   {
65514     try {
65515       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65516     } catch (std::out_of_range& e) {
65517       {
65518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65519       };
65520     } catch (std::exception& e) {
65521       {
65522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65523       };
65524     } catch (...) {
65525       {
65526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65527       };
65528     }
65529   }
65530   jresult = (void *)result;
65531   return jresult;
65532 }
65533
65534
65535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65536   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65537
65538   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
65539   {
65540     try {
65541       delete arg1;
65542     } catch (std::out_of_range& e) {
65543       {
65544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65545       };
65546     } catch (std::exception& e) {
65547       {
65548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65549       };
65550     } catch (...) {
65551       {
65552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65553       };
65554     }
65555   }
65556 }
65557
65558
65559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
65560   int jresult ;
65561   int result;
65562
65563   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
65564   jresult = (int)result;
65565   return jresult;
65566 }
65567
65568
65569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
65570   int jresult ;
65571   int result;
65572
65573   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
65574   jresult = (int)result;
65575   return jresult;
65576 }
65577
65578
65579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
65580   int jresult ;
65581   int result;
65582
65583   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
65584   jresult = (int)result;
65585   return jresult;
65586 }
65587
65588
65589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
65590   void * jresult ;
65591   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
65592
65593   {
65594     try {
65595       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
65596     } catch (std::out_of_range& e) {
65597       {
65598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65599       };
65600     } catch (std::exception& e) {
65601       {
65602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65603       };
65604     } catch (...) {
65605       {
65606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65607       };
65608     }
65609   }
65610   jresult = (void *)result;
65611   return jresult;
65612 }
65613
65614
65615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
65616   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
65617
65618   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
65619   {
65620     try {
65621       delete arg1;
65622     } catch (std::out_of_range& e) {
65623       {
65624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65625       };
65626     } catch (std::exception& e) {
65627       {
65628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65629       };
65630     } catch (...) {
65631       {
65632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65633       };
65634     }
65635   }
65636 }
65637
65638
65639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
65640   void * jresult ;
65641   Dali::Toolkit::FlexContainer *result = 0 ;
65642
65643   {
65644     try {
65645       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
65646     } catch (std::out_of_range& e) {
65647       {
65648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65649       };
65650     } catch (std::exception& e) {
65651       {
65652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65653       };
65654     } catch (...) {
65655       {
65656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65657       };
65658     }
65659   }
65660   jresult = (void *)result;
65661   return jresult;
65662 }
65663
65664
65665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
65666   void * jresult ;
65667   Dali::Toolkit::FlexContainer *arg1 = 0 ;
65668   Dali::Toolkit::FlexContainer *result = 0 ;
65669
65670   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65671   if (!arg1) {
65672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65673     return 0;
65674   }
65675   {
65676     try {
65677       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
65678     } catch (std::out_of_range& e) {
65679       {
65680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65681       };
65682     } catch (std::exception& e) {
65683       {
65684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65685       };
65686     } catch (...) {
65687       {
65688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65689       };
65690     }
65691   }
65692   jresult = (void *)result;
65693   return jresult;
65694 }
65695
65696
65697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
65698   void * jresult ;
65699   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65700   Dali::Toolkit::FlexContainer *arg2 = 0 ;
65701   Dali::Toolkit::FlexContainer *result = 0 ;
65702
65703   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65704   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
65705   if (!arg2) {
65706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65707     return 0;
65708   }
65709   {
65710     try {
65711       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
65712     } catch (std::out_of_range& e) {
65713       {
65714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65715       };
65716     } catch (std::exception& e) {
65717       {
65718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65719       };
65720     } catch (...) {
65721       {
65722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65723       };
65724     }
65725   }
65726   jresult = (void *)result;
65727   return jresult;
65728 }
65729
65730
65731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
65732   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65733
65734   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65735   {
65736     try {
65737       delete arg1;
65738     } catch (std::out_of_range& e) {
65739       {
65740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65741       };
65742     } catch (std::exception& e) {
65743       {
65744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65745       };
65746     } catch (...) {
65747       {
65748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65749       };
65750     }
65751   }
65752 }
65753
65754
65755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
65756   void * jresult ;
65757   Dali::Toolkit::FlexContainer result;
65758
65759   {
65760     try {
65761       result = Dali::Toolkit::FlexContainer::New();
65762     } catch (std::out_of_range& e) {
65763       {
65764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65765       };
65766     } catch (std::exception& e) {
65767       {
65768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65769       };
65770     } catch (...) {
65771       {
65772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65773       };
65774     }
65775   }
65776   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65777   return jresult;
65778 }
65779
65780
65781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
65782   void * jresult ;
65783   Dali::BaseHandle arg1 ;
65784   Dali::BaseHandle *argp1 ;
65785   Dali::Toolkit::FlexContainer result;
65786
65787   argp1 = (Dali::BaseHandle *)jarg1;
65788   if (!argp1) {
65789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65790     return 0;
65791   }
65792   arg1 = *argp1;
65793   {
65794     try {
65795       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
65796     } catch (std::out_of_range& e) {
65797       {
65798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65799       };
65800     } catch (std::exception& e) {
65801       {
65802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65803       };
65804     } catch (...) {
65805       {
65806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65807       };
65808     }
65809   }
65810   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
65811   return jresult;
65812 }
65813
65814
65815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
65816   int jresult ;
65817   int result;
65818
65819   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
65820   jresult = (int)result;
65821   return jresult;
65822 }
65823
65824
65825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
65826   int jresult ;
65827   int result;
65828
65829   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
65830   jresult = (int)result;
65831   return jresult;
65832 }
65833
65834
65835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
65836   int jresult ;
65837   int result;
65838
65839   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
65840   jresult = (int)result;
65841   return jresult;
65842 }
65843
65844
65845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
65846   int jresult ;
65847   int result;
65848
65849   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
65850   jresult = (int)result;
65851   return jresult;
65852 }
65853
65854
65855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
65856   void * jresult ;
65857   Dali::Toolkit::ImageView::Property *result = 0 ;
65858
65859   {
65860     try {
65861       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
65862     } catch (std::out_of_range& e) {
65863       {
65864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65865       };
65866     } catch (std::exception& e) {
65867       {
65868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65869       };
65870     } catch (...) {
65871       {
65872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65873       };
65874     }
65875   }
65876   jresult = (void *)result;
65877   return jresult;
65878 }
65879
65880
65881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
65882   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
65883
65884   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
65885   {
65886     try {
65887       delete arg1;
65888     } catch (std::out_of_range& e) {
65889       {
65890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65891       };
65892     } catch (std::exception& e) {
65893       {
65894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65895       };
65896     } catch (...) {
65897       {
65898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65899       };
65900     }
65901   }
65902 }
65903
65904
65905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
65906   void * jresult ;
65907   Dali::Toolkit::ImageView *result = 0 ;
65908
65909   {
65910     try {
65911       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
65912     } catch (std::out_of_range& e) {
65913       {
65914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65915       };
65916     } catch (std::exception& e) {
65917       {
65918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65919       };
65920     } catch (...) {
65921       {
65922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65923       };
65924     }
65925   }
65926   jresult = (void *)result;
65927   return jresult;
65928 }
65929
65930
65931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
65932   void * jresult ;
65933   Dali::Toolkit::ImageView result;
65934
65935   {
65936     try {
65937       result = Dali::Toolkit::ImageView::New();
65938     } catch (std::out_of_range& e) {
65939       {
65940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65941       };
65942     } catch (std::exception& e) {
65943       {
65944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65945       };
65946     } catch (...) {
65947       {
65948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65949       };
65950     }
65951   }
65952   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
65953   return jresult;
65954 }
65955
65956
65957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
65958   void * jresult ;
65959   Dali::Image arg1 ;
65960   Dali::Image *argp1 ;
65961   Dali::Toolkit::ImageView result;
65962
65963   argp1 = (Dali::Image *)jarg1;
65964   if (!argp1) {
65965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65966     return 0;
65967   }
65968   arg1 = *argp1;
65969   {
65970     try {
65971       result = Dali::Toolkit::ImageView::New(arg1);
65972     } catch (std::out_of_range& e) {
65973       {
65974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65975       };
65976     } catch (std::exception& e) {
65977       {
65978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65979       };
65980     } catch (...) {
65981       {
65982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65983       };
65984     }
65985   }
65986   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
65987   return jresult;
65988 }
65989
65990
65991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
65992   void * jresult ;
65993   std::string *arg1 = 0 ;
65994   Dali::Toolkit::ImageView result;
65995
65996   if (!jarg1) {
65997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65998     return 0;
65999   }
66000   std::string arg1_str(jarg1);
66001   arg1 = &arg1_str;
66002   {
66003     try {
66004       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66005     } catch (std::out_of_range& e) {
66006       {
66007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66008       };
66009     } catch (std::exception& e) {
66010       {
66011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66012       };
66013     } catch (...) {
66014       {
66015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66016       };
66017     }
66018   }
66019   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66020
66021   //argout typemap for const std::string&
66022
66023   return jresult;
66024 }
66025
66026
66027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66028   void * jresult ;
66029   std::string *arg1 = 0 ;
66030   Dali::ImageDimensions arg2 ;
66031   Dali::ImageDimensions *argp2 ;
66032   Dali::Toolkit::ImageView result;
66033
66034   if (!jarg1) {
66035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66036     return 0;
66037   }
66038   std::string arg1_str(jarg1);
66039   arg1 = &arg1_str;
66040   argp2 = (Dali::ImageDimensions *)jarg2;
66041   if (!argp2) {
66042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66043     return 0;
66044   }
66045   arg2 = *argp2;
66046   {
66047     try {
66048       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66049     } catch (std::out_of_range& e) {
66050       {
66051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66052       };
66053     } catch (std::exception& e) {
66054       {
66055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66056       };
66057     } catch (...) {
66058       {
66059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66060       };
66061     }
66062   }
66063   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66064
66065   //argout typemap for const std::string&
66066
66067   return jresult;
66068 }
66069
66070
66071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66072   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66073
66074   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66075   {
66076     try {
66077       delete arg1;
66078     } catch (std::out_of_range& e) {
66079       {
66080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66081       };
66082     } catch (std::exception& e) {
66083       {
66084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66085       };
66086     } catch (...) {
66087       {
66088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66089       };
66090     }
66091   }
66092 }
66093
66094
66095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66096   void * jresult ;
66097   Dali::Toolkit::ImageView *arg1 = 0 ;
66098   Dali::Toolkit::ImageView *result = 0 ;
66099
66100   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66101   if (!arg1) {
66102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66103     return 0;
66104   }
66105   {
66106     try {
66107       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66108     } catch (std::out_of_range& e) {
66109       {
66110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66111       };
66112     } catch (std::exception& e) {
66113       {
66114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66115       };
66116     } catch (...) {
66117       {
66118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66119       };
66120     }
66121   }
66122   jresult = (void *)result;
66123   return jresult;
66124 }
66125
66126
66127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66128   void * jresult ;
66129   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66130   Dali::Toolkit::ImageView *arg2 = 0 ;
66131   Dali::Toolkit::ImageView *result = 0 ;
66132
66133   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66134   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66135   if (!arg2) {
66136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66137     return 0;
66138   }
66139   {
66140     try {
66141       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66142     } catch (std::out_of_range& e) {
66143       {
66144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66145       };
66146     } catch (std::exception& e) {
66147       {
66148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66149       };
66150     } catch (...) {
66151       {
66152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66153       };
66154     }
66155   }
66156   jresult = (void *)result;
66157   return jresult;
66158 }
66159
66160
66161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66162   void * jresult ;
66163   Dali::BaseHandle arg1 ;
66164   Dali::BaseHandle *argp1 ;
66165   Dali::Toolkit::ImageView result;
66166
66167   argp1 = (Dali::BaseHandle *)jarg1;
66168   if (!argp1) {
66169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66170     return 0;
66171   }
66172   arg1 = *argp1;
66173   {
66174     try {
66175       result = Dali::Toolkit::ImageView::DownCast(arg1);
66176     } catch (std::out_of_range& e) {
66177       {
66178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66179       };
66180     } catch (std::exception& e) {
66181       {
66182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66183       };
66184     } catch (...) {
66185       {
66186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66187       };
66188     }
66189   }
66190   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66191   return jresult;
66192 }
66193
66194
66195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
66196   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66197   Dali::Image arg2 ;
66198   Dali::Image *argp2 ;
66199
66200   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66201   argp2 = (Dali::Image *)jarg2;
66202   if (!argp2) {
66203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66204     return ;
66205   }
66206   arg2 = *argp2;
66207   {
66208     try {
66209       (arg1)->SetImage(arg2);
66210     } catch (std::out_of_range& e) {
66211       {
66212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66213       };
66214     } catch (std::exception& e) {
66215       {
66216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66217       };
66218     } catch (...) {
66219       {
66220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66221       };
66222     }
66223   }
66224 }
66225
66226
66227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66228   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66229   std::string *arg2 = 0 ;
66230
66231   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66232   if (!jarg2) {
66233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66234     return ;
66235   }
66236   std::string arg2_str(jarg2);
66237   arg2 = &arg2_str;
66238   {
66239     try {
66240       (arg1)->SetImage((std::string const &)*arg2);
66241     } catch (std::out_of_range& e) {
66242       {
66243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66244       };
66245     } catch (std::exception& e) {
66246       {
66247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66248       };
66249     } catch (...) {
66250       {
66251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66252       };
66253     }
66254   }
66255
66256   //argout typemap for const std::string&
66257
66258 }
66259
66260
66261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66262   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66263   std::string *arg2 = 0 ;
66264   Dali::ImageDimensions arg3 ;
66265   Dali::ImageDimensions *argp3 ;
66266
66267   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66268   if (!jarg2) {
66269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66270     return ;
66271   }
66272   std::string arg2_str(jarg2);
66273   arg2 = &arg2_str;
66274   argp3 = (Dali::ImageDimensions *)jarg3;
66275   if (!argp3) {
66276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66277     return ;
66278   }
66279   arg3 = *argp3;
66280   {
66281     try {
66282       (arg1)->SetImage((std::string const &)*arg2,arg3);
66283     } catch (std::out_of_range& e) {
66284       {
66285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66286       };
66287     } catch (std::exception& e) {
66288       {
66289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66290       };
66291     } catch (...) {
66292       {
66293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66294       };
66295     }
66296   }
66297
66298   //argout typemap for const std::string&
66299
66300 }
66301
66302
66303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
66304   void * jresult ;
66305   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66306   Dali::Image result;
66307
66308   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66309   {
66310     try {
66311       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
66312     } catch (std::out_of_range& e) {
66313       {
66314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66315       };
66316     } catch (std::exception& e) {
66317       {
66318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66319       };
66320     } catch (...) {
66321       {
66322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66323       };
66324     }
66325   }
66326   jresult = new Dali::Image((const Dali::Image &)result);
66327   return jresult;
66328 }
66329
66330
66331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66332   int jresult ;
66333   int result;
66334
66335   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66336   jresult = (int)result;
66337   return jresult;
66338 }
66339
66340
66341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66342   int jresult ;
66343   int result;
66344
66345   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66346   jresult = (int)result;
66347   return jresult;
66348 }
66349
66350
66351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66352   int jresult ;
66353   int result;
66354
66355   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66356   jresult = (int)result;
66357   return jresult;
66358 }
66359
66360
66361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66362   int jresult ;
66363   int result;
66364
66365   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66366   jresult = (int)result;
66367   return jresult;
66368 }
66369
66370
66371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66372   int jresult ;
66373   int result;
66374
66375   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66376   jresult = (int)result;
66377   return jresult;
66378 }
66379
66380
66381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66382   int jresult ;
66383   int result;
66384
66385   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66386   jresult = (int)result;
66387   return jresult;
66388 }
66389
66390
66391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66392   int jresult ;
66393   int result;
66394
66395   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66396   jresult = (int)result;
66397   return jresult;
66398 }
66399
66400
66401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66402   int jresult ;
66403   int result;
66404
66405   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66406   jresult = (int)result;
66407   return jresult;
66408 }
66409
66410
66411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66412   void * jresult ;
66413   Dali::Toolkit::Model3dView::Property *result = 0 ;
66414
66415   {
66416     try {
66417       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66418     } catch (std::out_of_range& e) {
66419       {
66420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66421       };
66422     } catch (std::exception& e) {
66423       {
66424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66425       };
66426     } catch (...) {
66427       {
66428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66429       };
66430     }
66431   }
66432   jresult = (void *)result;
66433   return jresult;
66434 }
66435
66436
66437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66438   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66439
66440   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66441   {
66442     try {
66443       delete arg1;
66444     } catch (std::out_of_range& e) {
66445       {
66446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66447       };
66448     } catch (std::exception& e) {
66449       {
66450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66451       };
66452     } catch (...) {
66453       {
66454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66455       };
66456     }
66457   }
66458 }
66459
66460
66461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66462   void * jresult ;
66463   Dali::Toolkit::Model3dView result;
66464
66465   {
66466     try {
66467       result = Dali::Toolkit::Model3dView::New();
66468     } catch (std::out_of_range& e) {
66469       {
66470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66471       };
66472     } catch (std::exception& e) {
66473       {
66474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66475       };
66476     } catch (...) {
66477       {
66478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66479       };
66480     }
66481   }
66482   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66483   return jresult;
66484 }
66485
66486
66487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66488   void * jresult ;
66489   std::string *arg1 = 0 ;
66490   std::string *arg2 = 0 ;
66491   std::string *arg3 = 0 ;
66492   Dali::Toolkit::Model3dView result;
66493
66494   if (!jarg1) {
66495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66496     return 0;
66497   }
66498   std::string arg1_str(jarg1);
66499   arg1 = &arg1_str;
66500   if (!jarg2) {
66501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66502     return 0;
66503   }
66504   std::string arg2_str(jarg2);
66505   arg2 = &arg2_str;
66506   if (!jarg3) {
66507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66508     return 0;
66509   }
66510   std::string arg3_str(jarg3);
66511   arg3 = &arg3_str;
66512   {
66513     try {
66514       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66515     } catch (std::out_of_range& e) {
66516       {
66517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66518       };
66519     } catch (std::exception& e) {
66520       {
66521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66522       };
66523     } catch (...) {
66524       {
66525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66526       };
66527     }
66528   }
66529   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66530
66531   //argout typemap for const std::string&
66532
66533
66534   //argout typemap for const std::string&
66535
66536
66537   //argout typemap for const std::string&
66538
66539   return jresult;
66540 }
66541
66542
66543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
66544   void * jresult ;
66545   Dali::Toolkit::Model3dView *result = 0 ;
66546
66547   {
66548     try {
66549       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
66550     } catch (std::out_of_range& e) {
66551       {
66552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66553       };
66554     } catch (std::exception& e) {
66555       {
66556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66557       };
66558     } catch (...) {
66559       {
66560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66561       };
66562     }
66563   }
66564   jresult = (void *)result;
66565   return jresult;
66566 }
66567
66568
66569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
66570   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66571
66572   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66573   {
66574     try {
66575       delete arg1;
66576     } catch (std::out_of_range& e) {
66577       {
66578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66579       };
66580     } catch (std::exception& e) {
66581       {
66582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66583       };
66584     } catch (...) {
66585       {
66586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66587       };
66588     }
66589   }
66590 }
66591
66592
66593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
66594   void * jresult ;
66595   Dali::Toolkit::Model3dView *arg1 = 0 ;
66596   Dali::Toolkit::Model3dView *result = 0 ;
66597
66598   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66599   if (!arg1) {
66600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66601     return 0;
66602   }
66603   {
66604     try {
66605       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
66606     } catch (std::out_of_range& e) {
66607       {
66608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66609       };
66610     } catch (std::exception& e) {
66611       {
66612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66613       };
66614     } catch (...) {
66615       {
66616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66617       };
66618     }
66619   }
66620   jresult = (void *)result;
66621   return jresult;
66622 }
66623
66624
66625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
66626   void * jresult ;
66627   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66628   Dali::Toolkit::Model3dView *arg2 = 0 ;
66629   Dali::Toolkit::Model3dView *result = 0 ;
66630
66631   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66632   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
66633   if (!arg2) {
66634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66635     return 0;
66636   }
66637   {
66638     try {
66639       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
66640     } catch (std::out_of_range& e) {
66641       {
66642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66643       };
66644     } catch (std::exception& e) {
66645       {
66646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66647       };
66648     } catch (...) {
66649       {
66650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66651       };
66652     }
66653   }
66654   jresult = (void *)result;
66655   return jresult;
66656 }
66657
66658
66659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
66660   void * jresult ;
66661   Dali::BaseHandle arg1 ;
66662   Dali::BaseHandle *argp1 ;
66663   Dali::Toolkit::Model3dView result;
66664
66665   argp1 = (Dali::BaseHandle *)jarg1;
66666   if (!argp1) {
66667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66668     return 0;
66669   }
66670   arg1 = *argp1;
66671   {
66672     try {
66673       result = Dali::Toolkit::Model3dView::DownCast(arg1);
66674     } catch (std::out_of_range& e) {
66675       {
66676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66677       };
66678     } catch (std::exception& e) {
66679       {
66680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66681       };
66682     } catch (...) {
66683       {
66684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66685       };
66686     }
66687   }
66688   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66689   return jresult;
66690 }
66691
66692
66693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
66694   int jresult ;
66695   int result;
66696
66697   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
66698   jresult = (int)result;
66699   return jresult;
66700 }
66701
66702
66703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
66704   int jresult ;
66705   int result;
66706
66707   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
66708   jresult = (int)result;
66709   return jresult;
66710 }
66711
66712
66713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
66714   int jresult ;
66715   int result;
66716
66717   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
66718   jresult = (int)result;
66719   return jresult;
66720 }
66721
66722
66723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
66724   int jresult ;
66725   int result;
66726
66727   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
66728   jresult = (int)result;
66729   return jresult;
66730 }
66731
66732
66733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
66734   int jresult ;
66735   int result;
66736
66737   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
66738   jresult = (int)result;
66739   return jresult;
66740 }
66741
66742
66743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
66744   int jresult ;
66745   int result;
66746
66747   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
66748   jresult = (int)result;
66749   return jresult;
66750 }
66751
66752
66753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
66754   int jresult ;
66755   int result;
66756
66757   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
66758   jresult = (int)result;
66759   return jresult;
66760 }
66761
66762
66763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
66764   int jresult ;
66765   int result;
66766
66767   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
66768   jresult = (int)result;
66769   return jresult;
66770 }
66771
66772
66773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
66774   int jresult ;
66775   int result;
66776
66777   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
66778   jresult = (int)result;
66779   return jresult;
66780 }
66781
66782
66783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
66784   void * jresult ;
66785   Dali::Toolkit::ScrollBar::Property *result = 0 ;
66786
66787   {
66788     try {
66789       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
66790     } catch (std::out_of_range& e) {
66791       {
66792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66793       };
66794     } catch (std::exception& e) {
66795       {
66796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66797       };
66798     } catch (...) {
66799       {
66800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66801       };
66802     }
66803   }
66804   jresult = (void *)result;
66805   return jresult;
66806 }
66807
66808
66809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
66810   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
66811
66812   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
66813   {
66814     try {
66815       delete arg1;
66816     } catch (std::out_of_range& e) {
66817       {
66818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66819       };
66820     } catch (std::exception& e) {
66821       {
66822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66823       };
66824     } catch (...) {
66825       {
66826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66827       };
66828     }
66829   }
66830 }
66831
66832
66833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
66834   void * jresult ;
66835   Dali::Toolkit::ScrollBar *result = 0 ;
66836
66837   {
66838     try {
66839       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
66840     } catch (std::out_of_range& e) {
66841       {
66842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66843       };
66844     } catch (std::exception& e) {
66845       {
66846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66847       };
66848     } catch (...) {
66849       {
66850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66851       };
66852     }
66853   }
66854   jresult = (void *)result;
66855   return jresult;
66856 }
66857
66858
66859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
66860   void * jresult ;
66861   Dali::Toolkit::ScrollBar *arg1 = 0 ;
66862   Dali::Toolkit::ScrollBar *result = 0 ;
66863
66864   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66865   if (!arg1) {
66866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
66867     return 0;
66868   }
66869   {
66870     try {
66871       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
66872     } catch (std::out_of_range& e) {
66873       {
66874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66875       };
66876     } catch (std::exception& e) {
66877       {
66878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66879       };
66880     } catch (...) {
66881       {
66882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66883       };
66884     }
66885   }
66886   jresult = (void *)result;
66887   return jresult;
66888 }
66889
66890
66891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
66892   void * jresult ;
66893   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66894   Dali::Toolkit::ScrollBar *arg2 = 0 ;
66895   Dali::Toolkit::ScrollBar *result = 0 ;
66896
66897   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66898   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
66899   if (!arg2) {
66900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
66901     return 0;
66902   }
66903   {
66904     try {
66905       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
66906     } catch (std::out_of_range& e) {
66907       {
66908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66909       };
66910     } catch (std::exception& e) {
66911       {
66912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66913       };
66914     } catch (...) {
66915       {
66916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66917       };
66918     }
66919   }
66920   jresult = (void *)result;
66921   return jresult;
66922 }
66923
66924
66925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
66926   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
66927
66928   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
66929   {
66930     try {
66931       delete arg1;
66932     } catch (std::out_of_range& e) {
66933       {
66934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66935       };
66936     } catch (std::exception& e) {
66937       {
66938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66939       };
66940     } catch (...) {
66941       {
66942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66943       };
66944     }
66945   }
66946 }
66947
66948
66949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
66950   void * jresult ;
66951   Dali::Toolkit::ScrollBar::Direction arg1 ;
66952   Dali::Toolkit::ScrollBar result;
66953
66954   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
66955   {
66956     try {
66957       result = Dali::Toolkit::ScrollBar::New(arg1);
66958     } catch (std::out_of_range& e) {
66959       {
66960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66961       };
66962     } catch (std::exception& e) {
66963       {
66964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66965       };
66966     } catch (...) {
66967       {
66968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66969       };
66970     }
66971   }
66972   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
66973   return jresult;
66974 }
66975
66976
66977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
66978   void * jresult ;
66979   Dali::Toolkit::ScrollBar result;
66980
66981   {
66982     try {
66983       result = Dali::Toolkit::ScrollBar::New();
66984     } catch (std::out_of_range& e) {
66985       {
66986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66987       };
66988     } catch (std::exception& e) {
66989       {
66990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66991       };
66992     } catch (...) {
66993       {
66994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66995       };
66996     }
66997   }
66998   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
66999   return jresult;
67000 }
67001
67002
67003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67004   void * jresult ;
67005   Dali::BaseHandle arg1 ;
67006   Dali::BaseHandle *argp1 ;
67007   Dali::Toolkit::ScrollBar result;
67008
67009   argp1 = (Dali::BaseHandle *)jarg1;
67010   if (!argp1) {
67011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67012     return 0;
67013   }
67014   arg1 = *argp1;
67015   {
67016     try {
67017       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67018     } catch (std::out_of_range& e) {
67019       {
67020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67021       };
67022     } catch (std::exception& e) {
67023       {
67024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67025       };
67026     } catch (...) {
67027       {
67028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67029       };
67030     }
67031   }
67032   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67033   return jresult;
67034 }
67035
67036
67037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67038   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67039   Dali::Handle arg2 ;
67040   Dali::Property::Index arg3 ;
67041   Dali::Property::Index arg4 ;
67042   Dali::Property::Index arg5 ;
67043   Dali::Property::Index arg6 ;
67044   Dali::Handle *argp2 ;
67045
67046   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67047   argp2 = (Dali::Handle *)jarg2;
67048   if (!argp2) {
67049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67050     return ;
67051   }
67052   arg2 = *argp2;
67053   arg3 = (Dali::Property::Index)jarg3;
67054   arg4 = (Dali::Property::Index)jarg4;
67055   arg5 = (Dali::Property::Index)jarg5;
67056   arg6 = (Dali::Property::Index)jarg6;
67057   {
67058     try {
67059       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67060     } catch (std::out_of_range& e) {
67061       {
67062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67063       };
67064     } catch (std::exception& e) {
67065       {
67066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67067       };
67068     } catch (...) {
67069       {
67070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67071       };
67072     }
67073   }
67074 }
67075
67076
67077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67078   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67079   Dali::Actor arg2 ;
67080   Dali::Actor *argp2 ;
67081
67082   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67083   argp2 = (Dali::Actor *)jarg2;
67084   if (!argp2) {
67085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67086     return ;
67087   }
67088   arg2 = *argp2;
67089   {
67090     try {
67091       (arg1)->SetScrollIndicator(arg2);
67092     } catch (std::out_of_range& e) {
67093       {
67094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67095       };
67096     } catch (std::exception& e) {
67097       {
67098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67099       };
67100     } catch (...) {
67101       {
67102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67103       };
67104     }
67105   }
67106 }
67107
67108
67109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67110   void * jresult ;
67111   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67112   Dali::Actor result;
67113
67114   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67115   {
67116     try {
67117       result = (arg1)->GetScrollIndicator();
67118     } catch (std::out_of_range& e) {
67119       {
67120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67121       };
67122     } catch (std::exception& e) {
67123       {
67124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67125       };
67126     } catch (...) {
67127       {
67128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67129       };
67130     }
67131   }
67132   jresult = new Dali::Actor((const Dali::Actor &)result);
67133   return jresult;
67134 }
67135
67136
67137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67138   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67139   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67140
67141   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67142   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67143   if (!arg2) {
67144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67145     return ;
67146   }
67147   {
67148     try {
67149       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67150     } catch (std::out_of_range& e) {
67151       {
67152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67153       };
67154     } catch (std::exception& e) {
67155       {
67156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67157       };
67158     } catch (...) {
67159       {
67160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67161       };
67162     }
67163   }
67164 }
67165
67166
67167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67168   void * jresult ;
67169   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67170   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
67171
67172   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67173   {
67174     try {
67175       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
67176     } catch (std::out_of_range& e) {
67177       {
67178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67179       };
67180     } catch (std::exception& e) {
67181       {
67182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67183       };
67184     } catch (...) {
67185       {
67186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67187       };
67188     }
67189   }
67190   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
67191   return jresult;
67192 }
67193
67194
67195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67196   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67197   Dali::Toolkit::ScrollBar::Direction arg2 ;
67198
67199   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67200   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67201   {
67202     try {
67203       (arg1)->SetScrollDirection(arg2);
67204     } catch (std::out_of_range& e) {
67205       {
67206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67207       };
67208     } catch (std::exception& e) {
67209       {
67210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67211       };
67212     } catch (...) {
67213       {
67214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67215       };
67216     }
67217   }
67218 }
67219
67220
67221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67222   int jresult ;
67223   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67224   Dali::Toolkit::ScrollBar::Direction result;
67225
67226   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67227   {
67228     try {
67229       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67230     } catch (std::out_of_range& e) {
67231       {
67232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67233       };
67234     } catch (std::exception& e) {
67235       {
67236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67237       };
67238     } catch (...) {
67239       {
67240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67241       };
67242     }
67243   }
67244   jresult = (int)result;
67245   return jresult;
67246 }
67247
67248
67249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67250   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67251   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67252
67253   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67254   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67255   {
67256     try {
67257       (arg1)->SetIndicatorHeightPolicy(arg2);
67258     } catch (std::out_of_range& e) {
67259       {
67260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67261       };
67262     } catch (std::exception& e) {
67263       {
67264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67265       };
67266     } catch (...) {
67267       {
67268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67269       };
67270     }
67271   }
67272 }
67273
67274
67275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67276   int jresult ;
67277   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67278   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67279
67280   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67281   {
67282     try {
67283       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67284     } catch (std::out_of_range& e) {
67285       {
67286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67287       };
67288     } catch (std::exception& e) {
67289       {
67290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67291       };
67292     } catch (...) {
67293       {
67294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67295       };
67296     }
67297   }
67298   jresult = (int)result;
67299   return jresult;
67300 }
67301
67302
67303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67304   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67305   float arg2 ;
67306
67307   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67308   arg2 = (float)jarg2;
67309   {
67310     try {
67311       (arg1)->SetIndicatorFixedHeight(arg2);
67312     } catch (std::out_of_range& e) {
67313       {
67314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67315       };
67316     } catch (std::exception& e) {
67317       {
67318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67319       };
67320     } catch (...) {
67321       {
67322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67323       };
67324     }
67325   }
67326 }
67327
67328
67329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67330   float jresult ;
67331   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67332   float result;
67333
67334   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67335   {
67336     try {
67337       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67338     } catch (std::out_of_range& e) {
67339       {
67340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67341       };
67342     } catch (std::exception& e) {
67343       {
67344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67345       };
67346     } catch (...) {
67347       {
67348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67349       };
67350     }
67351   }
67352   jresult = result;
67353   return jresult;
67354 }
67355
67356
67357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67358   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67359   float arg2 ;
67360
67361   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67362   arg2 = (float)jarg2;
67363   {
67364     try {
67365       (arg1)->SetIndicatorShowDuration(arg2);
67366     } catch (std::out_of_range& e) {
67367       {
67368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67369       };
67370     } catch (std::exception& e) {
67371       {
67372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67373       };
67374     } catch (...) {
67375       {
67376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67377       };
67378     }
67379   }
67380 }
67381
67382
67383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67384   float jresult ;
67385   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67386   float result;
67387
67388   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67389   {
67390     try {
67391       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67392     } catch (std::out_of_range& e) {
67393       {
67394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67395       };
67396     } catch (std::exception& e) {
67397       {
67398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67399       };
67400     } catch (...) {
67401       {
67402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67403       };
67404     }
67405   }
67406   jresult = result;
67407   return jresult;
67408 }
67409
67410
67411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67412   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67413   float arg2 ;
67414
67415   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67416   arg2 = (float)jarg2;
67417   {
67418     try {
67419       (arg1)->SetIndicatorHideDuration(arg2);
67420     } catch (std::out_of_range& e) {
67421       {
67422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67423       };
67424     } catch (std::exception& e) {
67425       {
67426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67427       };
67428     } catch (...) {
67429       {
67430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67431       };
67432     }
67433   }
67434 }
67435
67436
67437 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67438   float jresult ;
67439   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67440   float result;
67441
67442   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67443   {
67444     try {
67445       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67446     } catch (std::out_of_range& e) {
67447       {
67448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67449       };
67450     } catch (std::exception& e) {
67451       {
67452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67453       };
67454     } catch (...) {
67455       {
67456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67457       };
67458     }
67459   }
67460   jresult = result;
67461   return jresult;
67462 }
67463
67464
67465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
67466   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67467
67468   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67469   {
67470     try {
67471       (arg1)->ShowIndicator();
67472     } catch (std::out_of_range& e) {
67473       {
67474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67475       };
67476     } catch (std::exception& e) {
67477       {
67478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67479       };
67480     } catch (...) {
67481       {
67482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67483       };
67484     }
67485   }
67486 }
67487
67488
67489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
67490   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67491
67492   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67493   {
67494     try {
67495       (arg1)->HideIndicator();
67496     } catch (std::out_of_range& e) {
67497       {
67498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67499       };
67500     } catch (std::exception& e) {
67501       {
67502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67503       };
67504     } catch (...) {
67505       {
67506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67507       };
67508     }
67509   }
67510 }
67511
67512
67513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
67514   void * jresult ;
67515   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67516   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
67517
67518   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67519   {
67520     try {
67521       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
67522     } catch (std::out_of_range& e) {
67523       {
67524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67525       };
67526     } catch (std::exception& e) {
67527       {
67528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67529       };
67530     } catch (...) {
67531       {
67532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67533       };
67534     }
67535   }
67536   jresult = (void *)result;
67537   return jresult;
67538 }
67539
67540
67541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
67542   void * jresult ;
67543   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67544   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
67545
67546   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67547   {
67548     try {
67549       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
67550     } catch (std::out_of_range& e) {
67551       {
67552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67553       };
67554     } catch (std::exception& e) {
67555       {
67556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67557       };
67558     } catch (...) {
67559       {
67560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67561       };
67562     }
67563   }
67564   jresult = (void *)result;
67565   return jresult;
67566 }
67567
67568
67569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
67570   int jresult ;
67571   int result;
67572
67573   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
67574   jresult = (int)result;
67575   return jresult;
67576 }
67577
67578
67579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
67580   int jresult ;
67581   int result;
67582
67583   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
67584   jresult = (int)result;
67585   return jresult;
67586 }
67587
67588
67589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
67590   int jresult ;
67591   int result;
67592
67593   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
67594   jresult = (int)result;
67595   return jresult;
67596 }
67597
67598
67599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
67600   int jresult ;
67601   int result;
67602
67603   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
67604   jresult = (int)result;
67605   return jresult;
67606 }
67607
67608
67609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
67610   int jresult ;
67611   int result;
67612
67613   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
67614   jresult = (int)result;
67615   return jresult;
67616 }
67617
67618
67619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
67620   int jresult ;
67621   int result;
67622
67623   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
67624   jresult = (int)result;
67625   return jresult;
67626 }
67627
67628
67629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
67630   int jresult ;
67631   int result;
67632
67633   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
67634   jresult = (int)result;
67635   return jresult;
67636 }
67637
67638
67639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
67640   int jresult ;
67641   int result;
67642
67643   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
67644   jresult = (int)result;
67645   return jresult;
67646 }
67647
67648
67649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
67650   int jresult ;
67651   int result;
67652
67653   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
67654   jresult = (int)result;
67655   return jresult;
67656 }
67657
67658
67659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
67660   int jresult ;
67661   int result;
67662
67663   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
67664   jresult = (int)result;
67665   return jresult;
67666 }
67667
67668
67669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
67670   int jresult ;
67671   int result;
67672
67673   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
67674   jresult = (int)result;
67675   return jresult;
67676 }
67677
67678
67679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
67680   int jresult ;
67681   int result;
67682
67683   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
67684   jresult = (int)result;
67685   return jresult;
67686 }
67687
67688
67689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
67690   int jresult ;
67691   int result;
67692
67693   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
67694   jresult = (int)result;
67695   return jresult;
67696 }
67697
67698
67699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
67700   int jresult ;
67701   int result;
67702
67703   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
67704   jresult = (int)result;
67705   return jresult;
67706 }
67707
67708
67709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
67710   void * jresult ;
67711   Dali::Toolkit::Scrollable::Property *result = 0 ;
67712
67713   {
67714     try {
67715       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
67716     } catch (std::out_of_range& e) {
67717       {
67718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67719       };
67720     } catch (std::exception& e) {
67721       {
67722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67723       };
67724     } catch (...) {
67725       {
67726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67727       };
67728     }
67729   }
67730   jresult = (void *)result;
67731   return jresult;
67732 }
67733
67734
67735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
67736   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
67737
67738   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
67739   {
67740     try {
67741       delete arg1;
67742     } catch (std::out_of_range& e) {
67743       {
67744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67745       };
67746     } catch (std::exception& e) {
67747       {
67748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67749       };
67750     } catch (...) {
67751       {
67752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67753       };
67754     }
67755   }
67756 }
67757
67758
67759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
67760   void * jresult ;
67761   Dali::Toolkit::Scrollable *result = 0 ;
67762
67763   {
67764     try {
67765       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
67766     } catch (std::out_of_range& e) {
67767       {
67768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67769       };
67770     } catch (std::exception& e) {
67771       {
67772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67773       };
67774     } catch (...) {
67775       {
67776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67777       };
67778     }
67779   }
67780   jresult = (void *)result;
67781   return jresult;
67782 }
67783
67784
67785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
67786   void * jresult ;
67787   Dali::Toolkit::Scrollable *arg1 = 0 ;
67788   Dali::Toolkit::Scrollable *result = 0 ;
67789
67790   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67791   if (!arg1) {
67792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
67793     return 0;
67794   }
67795   {
67796     try {
67797       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
67798     } catch (std::out_of_range& e) {
67799       {
67800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67801       };
67802     } catch (std::exception& e) {
67803       {
67804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67805       };
67806     } catch (...) {
67807       {
67808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67809       };
67810     }
67811   }
67812   jresult = (void *)result;
67813   return jresult;
67814 }
67815
67816
67817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
67818   void * jresult ;
67819   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67820   Dali::Toolkit::Scrollable *arg2 = 0 ;
67821   Dali::Toolkit::Scrollable *result = 0 ;
67822
67823   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67824   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
67825   if (!arg2) {
67826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
67827     return 0;
67828   }
67829   {
67830     try {
67831       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
67832     } catch (std::out_of_range& e) {
67833       {
67834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67835       };
67836     } catch (std::exception& e) {
67837       {
67838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67839       };
67840     } catch (...) {
67841       {
67842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67843       };
67844     }
67845   }
67846   jresult = (void *)result;
67847   return jresult;
67848 }
67849
67850
67851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
67852   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67853
67854   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67855   {
67856     try {
67857       delete arg1;
67858     } catch (std::out_of_range& e) {
67859       {
67860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67861       };
67862     } catch (std::exception& e) {
67863       {
67864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67865       };
67866     } catch (...) {
67867       {
67868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67869       };
67870     }
67871   }
67872 }
67873
67874
67875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
67876   void * jresult ;
67877   Dali::BaseHandle arg1 ;
67878   Dali::BaseHandle *argp1 ;
67879   Dali::Toolkit::Scrollable result;
67880
67881   argp1 = (Dali::BaseHandle *)jarg1;
67882   if (!argp1) {
67883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67884     return 0;
67885   }
67886   arg1 = *argp1;
67887   {
67888     try {
67889       result = Dali::Toolkit::Scrollable::DownCast(arg1);
67890     } catch (std::out_of_range& e) {
67891       {
67892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67893       };
67894     } catch (std::exception& e) {
67895       {
67896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67897       };
67898     } catch (...) {
67899       {
67900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67901       };
67902     }
67903   }
67904   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
67905   return jresult;
67906 }
67907
67908
67909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
67910   unsigned int jresult ;
67911   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67912   bool result;
67913
67914   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67915   {
67916     try {
67917       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
67918     } catch (std::out_of_range& e) {
67919       {
67920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67921       };
67922     } catch (std::exception& e) {
67923       {
67924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67925       };
67926     } catch (...) {
67927       {
67928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67929       };
67930     }
67931   }
67932   jresult = result;
67933   return jresult;
67934 }
67935
67936
67937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
67938   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67939   bool arg2 ;
67940
67941   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67942   arg2 = jarg2 ? true : false;
67943   {
67944     try {
67945       (arg1)->SetOvershootEnabled(arg2);
67946     } catch (std::out_of_range& e) {
67947       {
67948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67949       };
67950     } catch (std::exception& e) {
67951       {
67952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67953       };
67954     } catch (...) {
67955       {
67956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67957       };
67958     }
67959   }
67960 }
67961
67962
67963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
67964   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67965   Dali::Vector4 *arg2 = 0 ;
67966
67967   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67968   arg2 = (Dali::Vector4 *)jarg2;
67969   if (!arg2) {
67970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67971     return ;
67972   }
67973   {
67974     try {
67975       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
67976     } catch (std::out_of_range& e) {
67977       {
67978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67979       };
67980     } catch (std::exception& e) {
67981       {
67982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67983       };
67984     } catch (...) {
67985       {
67986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67987       };
67988     }
67989   }
67990 }
67991
67992
67993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
67994   void * jresult ;
67995   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
67996   Dali::Vector4 result;
67997
67998   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
67999   {
68000     try {
68001       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68002     } catch (std::out_of_range& e) {
68003       {
68004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68005       };
68006     } catch (std::exception& e) {
68007       {
68008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68009       };
68010     } catch (...) {
68011       {
68012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68013       };
68014     }
68015   }
68016   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68017   return jresult;
68018 }
68019
68020
68021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68022   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68023   float arg2 ;
68024
68025   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68026   arg2 = (float)jarg2;
68027   {
68028     try {
68029       (arg1)->SetOvershootAnimationSpeed(arg2);
68030     } catch (std::out_of_range& e) {
68031       {
68032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68033       };
68034     } catch (std::exception& e) {
68035       {
68036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68037       };
68038     } catch (...) {
68039       {
68040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68041       };
68042     }
68043   }
68044 }
68045
68046
68047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68048   float jresult ;
68049   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68050   float result;
68051
68052   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68053   {
68054     try {
68055       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68056     } catch (std::out_of_range& e) {
68057       {
68058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68059       };
68060     } catch (std::exception& e) {
68061       {
68062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68063       };
68064     } catch (...) {
68065       {
68066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68067       };
68068     }
68069   }
68070   jresult = result;
68071   return jresult;
68072 }
68073
68074
68075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68076   void * jresult ;
68077   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68078   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68079
68080   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68081   {
68082     try {
68083       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
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 (...) {
68093       {
68094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68095       };
68096     }
68097   }
68098   jresult = (void *)result;
68099   return jresult;
68100 }
68101
68102
68103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68104   void * jresult ;
68105   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68106   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68107
68108   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68109   {
68110     try {
68111       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68112     } catch (std::out_of_range& e) {
68113       {
68114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68115       };
68116     } catch (std::exception& e) {
68117       {
68118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68119       };
68120     } catch (...) {
68121       {
68122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68123       };
68124     }
68125   }
68126   jresult = (void *)result;
68127   return jresult;
68128 }
68129
68130
68131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68132   void * jresult ;
68133   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68134   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68135
68136   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68137   {
68138     try {
68139       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68140     } catch (std::out_of_range& e) {
68141       {
68142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68143       };
68144     } catch (std::exception& e) {
68145       {
68146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68147       };
68148     } catch (...) {
68149       {
68150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68151       };
68152     }
68153   }
68154   jresult = (void *)result;
68155   return jresult;
68156 }
68157
68158
68159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68160   unsigned int jresult ;
68161   Dali::Toolkit::ControlOrientation::Type arg1 ;
68162   bool result;
68163
68164   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68165   {
68166     try {
68167       result = (bool)Dali::Toolkit::IsVertical(arg1);
68168     } catch (std::out_of_range& e) {
68169       {
68170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68171       };
68172     } catch (std::exception& e) {
68173       {
68174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68175       };
68176     } catch (...) {
68177       {
68178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68179       };
68180     }
68181   }
68182   jresult = result;
68183   return jresult;
68184 }
68185
68186
68187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68188   unsigned int jresult ;
68189   Dali::Toolkit::ControlOrientation::Type arg1 ;
68190   bool result;
68191
68192   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68193   {
68194     try {
68195       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68196     } catch (std::out_of_range& e) {
68197       {
68198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68199       };
68200     } catch (std::exception& e) {
68201       {
68202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68203       };
68204     } catch (...) {
68205       {
68206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68207       };
68208     }
68209   }
68210   jresult = result;
68211   return jresult;
68212 }
68213
68214
68215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68216   void * jresult ;
68217   unsigned int arg1 ;
68218   unsigned int arg2 ;
68219   Dali::Toolkit::ItemRange *result = 0 ;
68220
68221   arg1 = (unsigned int)jarg1;
68222   arg2 = (unsigned int)jarg2;
68223   {
68224     try {
68225       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68226     } catch (std::out_of_range& e) {
68227       {
68228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68229       };
68230     } catch (std::exception& e) {
68231       {
68232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68233       };
68234     } catch (...) {
68235       {
68236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68237       };
68238     }
68239   }
68240   jresult = (void *)result;
68241   return jresult;
68242 }
68243
68244
68245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68246   void * jresult ;
68247   Dali::Toolkit::ItemRange *arg1 = 0 ;
68248   Dali::Toolkit::ItemRange *result = 0 ;
68249
68250   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68251   if (!arg1) {
68252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68253     return 0;
68254   }
68255   {
68256     try {
68257       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68258     } catch (std::out_of_range& e) {
68259       {
68260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68261       };
68262     } catch (std::exception& e) {
68263       {
68264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68265       };
68266     } catch (...) {
68267       {
68268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68269       };
68270     }
68271   }
68272   jresult = (void *)result;
68273   return jresult;
68274 }
68275
68276
68277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68278   void * jresult ;
68279   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68280   Dali::Toolkit::ItemRange *arg2 = 0 ;
68281   Dali::Toolkit::ItemRange *result = 0 ;
68282
68283   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68284   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68285   if (!arg2) {
68286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68287     return 0;
68288   }
68289   {
68290     try {
68291       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
68292     } catch (std::out_of_range& e) {
68293       {
68294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68295       };
68296     } catch (std::exception& e) {
68297       {
68298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68299       };
68300     } catch (...) {
68301       {
68302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68303       };
68304     }
68305   }
68306   jresult = (void *)result;
68307   return jresult;
68308 }
68309
68310
68311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68312   unsigned int jresult ;
68313   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68314   unsigned int arg2 ;
68315   bool result;
68316
68317   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68318   arg2 = (unsigned int)jarg2;
68319   {
68320     try {
68321       result = (bool)(arg1)->Within(arg2);
68322     } catch (std::out_of_range& e) {
68323       {
68324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68325       };
68326     } catch (std::exception& e) {
68327       {
68328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68329       };
68330     } catch (...) {
68331       {
68332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68333       };
68334     }
68335   }
68336   jresult = result;
68337   return jresult;
68338 }
68339
68340
68341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
68342   void * jresult ;
68343   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68344   Dali::Toolkit::ItemRange *arg2 = 0 ;
68345   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68346
68347   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68348   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68349   if (!arg2) {
68350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68351     return 0;
68352   }
68353   {
68354     try {
68355       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
68356     } catch (std::out_of_range& e) {
68357       {
68358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68359       };
68360     } catch (std::exception& e) {
68361       {
68362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68363       };
68364     } catch (...) {
68365       {
68366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68367       };
68368     }
68369   }
68370   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68371   return jresult;
68372 }
68373
68374
68375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
68376   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68377   unsigned int arg2 ;
68378
68379   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68380   arg2 = (unsigned int)jarg2;
68381   if (arg1) (arg1)->begin = arg2;
68382 }
68383
68384
68385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
68386   unsigned int jresult ;
68387   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68388   unsigned int result;
68389
68390   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68391   result = (unsigned int) ((arg1)->begin);
68392   jresult = result;
68393   return jresult;
68394 }
68395
68396
68397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
68398   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68399   unsigned int arg2 ;
68400
68401   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68402   arg2 = (unsigned int)jarg2;
68403   if (arg1) (arg1)->end = arg2;
68404 }
68405
68406
68407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
68408   unsigned int jresult ;
68409   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68410   unsigned int result;
68411
68412   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68413   result = (unsigned int) ((arg1)->end);
68414   jresult = result;
68415   return jresult;
68416 }
68417
68418
68419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
68420   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68421
68422   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68423   {
68424     try {
68425       delete arg1;
68426     } catch (std::out_of_range& e) {
68427       {
68428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68429       };
68430     } catch (std::exception& e) {
68431       {
68432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68433       };
68434     } catch (...) {
68435       {
68436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68437       };
68438     }
68439   }
68440 }
68441
68442
68443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
68444   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68445
68446   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68447   {
68448     try {
68449       delete arg1;
68450     } catch (std::out_of_range& e) {
68451       {
68452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68453       };
68454     } catch (std::exception& e) {
68455       {
68456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68457       };
68458     } catch (...) {
68459       {
68460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68461       };
68462     }
68463   }
68464 }
68465
68466
68467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
68468   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68469   Dali::Toolkit::ControlOrientation::Type arg2 ;
68470
68471   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68472   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
68473   {
68474     try {
68475       (arg1)->SetOrientation(arg2);
68476     } catch (std::out_of_range& e) {
68477       {
68478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68479       };
68480     } catch (std::exception& e) {
68481       {
68482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68483       };
68484     } catch (...) {
68485       {
68486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68487       };
68488     }
68489   }
68490 }
68491
68492
68493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
68494   int jresult ;
68495   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68496   Dali::Toolkit::ControlOrientation::Type result;
68497
68498   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68499   {
68500     try {
68501       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
68502     } catch (std::out_of_range& e) {
68503       {
68504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68505       };
68506     } catch (std::exception& e) {
68507       {
68508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68509       };
68510     } catch (...) {
68511       {
68512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68513       };
68514     }
68515   }
68516   jresult = (int)result;
68517   return jresult;
68518 }
68519
68520
68521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
68522   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68523   Dali::Property::Map *arg2 = 0 ;
68524
68525   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68526   arg2 = (Dali::Property::Map *)jarg2;
68527   if (!arg2) {
68528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
68529     return ;
68530   }
68531   {
68532     try {
68533       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
68534     } catch (std::out_of_range& e) {
68535       {
68536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68537       };
68538     } catch (std::exception& e) {
68539       {
68540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68541       };
68542     } catch (...) {
68543       {
68544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68545       };
68546     }
68547   }
68548 }
68549
68550
68551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
68552   void * jresult ;
68553   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68554   Dali::Property::Map result;
68555
68556   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68557   {
68558     try {
68559       result = (arg1)->GetLayoutProperties();
68560     } catch (std::out_of_range& e) {
68561       {
68562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68563       };
68564     } catch (std::exception& e) {
68565       {
68566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68567       };
68568     } catch (...) {
68569       {
68570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68571       };
68572     }
68573   }
68574   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
68575   return jresult;
68576 }
68577
68578
68579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68580   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68581   unsigned int arg2 ;
68582   Dali::Vector3 *arg3 = 0 ;
68583   Dali::Vector3 *arg4 = 0 ;
68584
68585   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68586   arg2 = (unsigned int)jarg2;
68587   arg3 = (Dali::Vector3 *)jarg3;
68588   if (!arg3) {
68589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68590     return ;
68591   }
68592   arg4 = (Dali::Vector3 *)jarg4;
68593   if (!arg4) {
68594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68595     return ;
68596   }
68597   {
68598     try {
68599       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68600     } catch (std::out_of_range& e) {
68601       {
68602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68603       };
68604     } catch (std::exception& e) {
68605       {
68606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68607       };
68608     } catch (...) {
68609       {
68610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68611       };
68612     }
68613   }
68614 }
68615
68616
68617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
68618   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68619   Dali::Vector3 *arg2 = 0 ;
68620
68621   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68622   arg2 = (Dali::Vector3 *)jarg2;
68623   if (!arg2) {
68624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68625     return ;
68626   }
68627   {
68628     try {
68629       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
68630     } catch (std::out_of_range& e) {
68631       {
68632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68633       };
68634     } catch (std::exception& e) {
68635       {
68636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68637       };
68638     } catch (...) {
68639       {
68640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68641       };
68642     }
68643   }
68644 }
68645
68646
68647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
68648   float jresult ;
68649   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68650   unsigned int arg2 ;
68651   Dali::Vector3 arg3 ;
68652   Dali::Vector3 *argp3 ;
68653   float result;
68654
68655   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68656   arg2 = (unsigned int)jarg2;
68657   argp3 = (Dali::Vector3 *)jarg3;
68658   if (!argp3) {
68659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68660     return 0;
68661   }
68662   arg3 = *argp3;
68663   {
68664     try {
68665       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
68666     } catch (std::out_of_range& e) {
68667       {
68668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68669       };
68670     } catch (std::exception& e) {
68671       {
68672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68673       };
68674     } catch (...) {
68675       {
68676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68677       };
68678     }
68679   }
68680   jresult = result;
68681   return jresult;
68682 }
68683
68684
68685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
68686   float jresult ;
68687   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68688   float arg2 ;
68689   float result;
68690
68691   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68692   arg2 = (float)jarg2;
68693   {
68694     try {
68695       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
68696     } catch (std::out_of_range& e) {
68697       {
68698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68699       };
68700     } catch (std::exception& e) {
68701       {
68702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68703       };
68704     } catch (...) {
68705       {
68706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68707       };
68708     }
68709   }
68710   jresult = result;
68711   return jresult;
68712 }
68713
68714
68715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
68716   float jresult ;
68717   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68718   unsigned int arg2 ;
68719   float result;
68720
68721   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68722   arg2 = (unsigned int)jarg2;
68723   {
68724     try {
68725       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
68726     } catch (std::out_of_range& e) {
68727       {
68728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68729       };
68730     } catch (std::exception& e) {
68731       {
68732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68733       };
68734     } catch (...) {
68735       {
68736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68737       };
68738     }
68739   }
68740   jresult = result;
68741   return jresult;
68742 }
68743
68744
68745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
68746   void * jresult ;
68747   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68748   float arg2 ;
68749   Dali::Vector3 arg3 ;
68750   Dali::Vector3 *argp3 ;
68751   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68752
68753   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68754   arg2 = (float)jarg2;
68755   argp3 = (Dali::Vector3 *)jarg3;
68756   if (!argp3) {
68757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68758     return 0;
68759   }
68760   arg3 = *argp3;
68761   {
68762     try {
68763       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
68764     } catch (std::out_of_range& e) {
68765       {
68766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68767       };
68768     } catch (std::exception& e) {
68769       {
68770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68771       };
68772     } catch (...) {
68773       {
68774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68775       };
68776     }
68777   }
68778   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68779   return jresult;
68780 }
68781
68782
68783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
68784   float jresult ;
68785   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68786   int arg2 ;
68787   float arg3 ;
68788   Dali::Vector3 *arg4 = 0 ;
68789   float result;
68790
68791   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68792   arg2 = (int)jarg2;
68793   arg3 = (float)jarg3;
68794   arg4 = (Dali::Vector3 *)jarg4;
68795   if (!arg4) {
68796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68797     return 0;
68798   }
68799   {
68800     try {
68801       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
68802     } catch (std::out_of_range& e) {
68803       {
68804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68805       };
68806     } catch (std::exception& e) {
68807       {
68808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68809       };
68810     } catch (...) {
68811       {
68812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68813       };
68814     }
68815   }
68816   jresult = result;
68817   return jresult;
68818 }
68819
68820
68821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
68822   unsigned int jresult ;
68823   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68824   Dali::Vector3 arg2 ;
68825   Dali::Vector3 *argp2 ;
68826   unsigned int result;
68827
68828   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68829   argp2 = (Dali::Vector3 *)jarg2;
68830   if (!argp2) {
68831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68832     return 0;
68833   }
68834   arg2 = *argp2;
68835   {
68836     try {
68837       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
68838     } catch (std::out_of_range& e) {
68839       {
68840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68841       };
68842     } catch (std::exception& e) {
68843       {
68844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68845       };
68846     } catch (...) {
68847       {
68848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68849       };
68850     }
68851   }
68852   jresult = result;
68853   return jresult;
68854 }
68855
68856
68857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68858   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68859   unsigned int arg2 ;
68860   Dali::Vector3 *arg3 = 0 ;
68861   Dali::Vector3 *arg4 = 0 ;
68862
68863   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68864   arg2 = (unsigned int)jarg2;
68865   arg3 = (Dali::Vector3 *)jarg3;
68866   if (!arg3) {
68867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68868     return ;
68869   }
68870   arg4 = (Dali::Vector3 *)jarg4;
68871   if (!arg4) {
68872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68873     return ;
68874   }
68875   {
68876     try {
68877       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68878     } catch (std::out_of_range& e) {
68879       {
68880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68881       };
68882     } catch (std::exception& e) {
68883       {
68884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68885       };
68886     } catch (...) {
68887       {
68888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68889       };
68890     }
68891   }
68892 }
68893
68894
68895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
68896   void * jresult ;
68897   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68898   Dali::Degree result;
68899
68900   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68901   {
68902     try {
68903       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
68904     } catch (std::out_of_range& e) {
68905       {
68906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68907       };
68908     } catch (std::exception& e) {
68909       {
68910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68911       };
68912     } catch (...) {
68913       {
68914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68915       };
68916     }
68917   }
68918   jresult = new Dali::Degree((const Dali::Degree &)result);
68919   return jresult;
68920 }
68921
68922
68923 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
68924   float jresult ;
68925   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68926   float result;
68927
68928   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68929   {
68930     try {
68931       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
68932     } catch (std::out_of_range& e) {
68933       {
68934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68935       };
68936     } catch (std::exception& e) {
68937       {
68938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68939       };
68940     } catch (...) {
68941       {
68942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68943       };
68944     }
68945   }
68946   jresult = result;
68947   return jresult;
68948 }
68949
68950
68951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
68952   float jresult ;
68953   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68954   float result;
68955
68956   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68957   {
68958     try {
68959       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
68960     } catch (std::out_of_range& e) {
68961       {
68962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68963       };
68964     } catch (std::exception& e) {
68965       {
68966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68967       };
68968     } catch (...) {
68969       {
68970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68971       };
68972     }
68973   }
68974   jresult = result;
68975   return jresult;
68976 }
68977
68978
68979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
68980   float jresult ;
68981   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68982   float result;
68983
68984   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68985   {
68986     try {
68987       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
68988     } catch (std::out_of_range& e) {
68989       {
68990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68991       };
68992     } catch (std::exception& e) {
68993       {
68994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68995       };
68996     } catch (...) {
68997       {
68998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68999       };
69000     }
69001   }
69002   jresult = result;
69003   return jresult;
69004 }
69005
69006
69007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69008   int jresult ;
69009   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69010   int arg2 ;
69011   int arg3 ;
69012   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69013   bool arg5 ;
69014   int result;
69015
69016   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69017   arg2 = (int)jarg2;
69018   arg3 = (int)jarg3;
69019   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69020   arg5 = jarg5 ? true : false;
69021   {
69022     try {
69023       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69024     } catch (std::out_of_range& e) {
69025       {
69026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69027       };
69028     } catch (std::exception& e) {
69029       {
69030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69031       };
69032     } catch (...) {
69033       {
69034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69035       };
69036     }
69037   }
69038   jresult = result;
69039   return jresult;
69040 }
69041
69042
69043 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69044   float jresult ;
69045   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69046   float result;
69047
69048   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69049   {
69050     try {
69051       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69052     } catch (std::out_of_range& e) {
69053       {
69054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69055       };
69056     } catch (std::exception& e) {
69057       {
69058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69059       };
69060     } catch (...) {
69061       {
69062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69063       };
69064     }
69065   }
69066   jresult = result;
69067   return jresult;
69068 }
69069
69070
69071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69072   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69073   Dali::Actor *arg2 = 0 ;
69074   int arg3 ;
69075   Dali::Vector3 *arg4 = 0 ;
69076   Dali::Actor *arg5 = 0 ;
69077
69078   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69079   arg2 = (Dali::Actor *)jarg2;
69080   if (!arg2) {
69081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69082     return ;
69083   }
69084   arg3 = (int)jarg3;
69085   arg4 = (Dali::Vector3 *)jarg4;
69086   if (!arg4) {
69087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69088     return ;
69089   }
69090   arg5 = (Dali::Actor *)jarg5;
69091   if (!arg5) {
69092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69093     return ;
69094   }
69095   {
69096     try {
69097       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69098     } catch (std::out_of_range& e) {
69099       {
69100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69101       };
69102     } catch (std::exception& e) {
69103       {
69104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69105       };
69106     } catch (...) {
69107       {
69108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69109       };
69110     }
69111   }
69112 }
69113
69114
69115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69116   void * jresult ;
69117   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69118   int arg2 ;
69119   float arg3 ;
69120   Dali::Vector3 *arg4 = 0 ;
69121   Dali::Vector3 result;
69122
69123   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69124   arg2 = (int)jarg2;
69125   arg3 = (float)jarg3;
69126   arg4 = (Dali::Vector3 *)jarg4;
69127   if (!arg4) {
69128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69129     return 0;
69130   }
69131   {
69132     try {
69133       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69134     } catch (std::out_of_range& e) {
69135       {
69136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69137       };
69138     } catch (std::exception& e) {
69139       {
69140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69141       };
69142     } catch (...) {
69143       {
69144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69145       };
69146     }
69147   }
69148   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69149   return jresult;
69150 }
69151
69152
69153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
69154   void * jresult ;
69155   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
69156   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69157
69158   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
69159   {
69160     try {
69161       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
69162     } catch (std::out_of_range& e) {
69163       {
69164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69165       };
69166     } catch (std::exception& e) {
69167       {
69168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69169       };
69170     } catch (...) {
69171       {
69172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69173       };
69174     }
69175   }
69176   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69177   return jresult;
69178 }
69179
69180
69181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
69182   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69183
69184   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69185   {
69186     try {
69187       delete arg1;
69188     } catch (std::out_of_range& e) {
69189       {
69190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69191       };
69192     } catch (std::exception& e) {
69193       {
69194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69195       };
69196     } catch (...) {
69197       {
69198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69199       };
69200     }
69201   }
69202 }
69203
69204
69205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
69206   unsigned int jresult ;
69207   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69208   unsigned int result;
69209
69210   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69211   {
69212     try {
69213       result = (unsigned int)(arg1)->GetNumberOfItems();
69214     } catch (std::out_of_range& e) {
69215       {
69216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69217       };
69218     } catch (std::exception& e) {
69219       {
69220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69221       };
69222     } catch (...) {
69223       {
69224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69225       };
69226     }
69227   }
69228   jresult = result;
69229   return jresult;
69230 }
69231
69232
69233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
69234   void * jresult ;
69235   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69236   unsigned int arg2 ;
69237   Dali::Actor result;
69238
69239   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69240   arg2 = (unsigned int)jarg2;
69241   {
69242     try {
69243       result = (arg1)->NewItem(arg2);
69244     } catch (std::out_of_range& e) {
69245       {
69246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69247       };
69248     } catch (std::exception& e) {
69249       {
69250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69251       };
69252     } catch (...) {
69253       {
69254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69255       };
69256     }
69257   }
69258   jresult = new Dali::Actor((const Dali::Actor &)result);
69259   return jresult;
69260 }
69261
69262
69263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
69264   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69265   unsigned int arg2 ;
69266   Dali::Actor arg3 ;
69267   Dali::Actor *argp3 ;
69268
69269   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69270   arg2 = (unsigned int)jarg2;
69271   argp3 = (Dali::Actor *)jarg3;
69272   if (!argp3) {
69273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69274     return ;
69275   }
69276   arg3 = *argp3;
69277   {
69278     try {
69279       (arg1)->ItemReleased(arg2,arg3);
69280     } catch (std::out_of_range& e) {
69281       {
69282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69283       };
69284     } catch (std::exception& e) {
69285       {
69286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69287       };
69288     } catch (...) {
69289       {
69290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69291       };
69292     }
69293   }
69294 }
69295
69296
69297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
69298   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69299   unsigned int arg2 ;
69300   Dali::Actor arg3 ;
69301   Dali::Actor *argp3 ;
69302
69303   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69304   arg2 = (unsigned int)jarg2;
69305   argp3 = (Dali::Actor *)jarg3;
69306   if (!argp3) {
69307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69308     return ;
69309   }
69310   arg3 = *argp3;
69311   {
69312     try {
69313       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
69314     } catch (std::out_of_range& e) {
69315       {
69316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69317       };
69318     } catch (std::exception& e) {
69319       {
69320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69321       };
69322     } catch (...) {
69323       {
69324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69325       };
69326     }
69327   }
69328 }
69329
69330
69331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
69332   void * jresult ;
69333   Dali::Toolkit::ItemFactory *result = 0 ;
69334
69335   {
69336     try {
69337       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
69338     } catch (std::out_of_range& e) {
69339       {
69340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69341       };
69342     } catch (std::exception& e) {
69343       {
69344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69345       };
69346     } catch (...) {
69347       {
69348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69349       };
69350     }
69351   }
69352   jresult = (void *)result;
69353   return jresult;
69354 }
69355
69356
69357 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) {
69358   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
69359   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
69360   if (director) {
69361     director->swig_connect_director(callback0, callback1, callback2);
69362   }
69363 }
69364
69365
69366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
69367   int jresult ;
69368   int result;
69369
69370   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
69371   jresult = (int)result;
69372   return jresult;
69373 }
69374
69375
69376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
69377   int jresult ;
69378   int result;
69379
69380   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
69381   jresult = (int)result;
69382   return jresult;
69383 }
69384
69385
69386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69387   int jresult ;
69388   int result;
69389
69390   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69391   jresult = (int)result;
69392   return jresult;
69393 }
69394
69395
69396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
69397   int jresult ;
69398   int result;
69399
69400   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
69401   jresult = (int)result;
69402   return jresult;
69403 }
69404
69405
69406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
69407   int jresult ;
69408   int result;
69409
69410   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
69411   jresult = (int)result;
69412   return jresult;
69413 }
69414
69415
69416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
69417   int jresult ;
69418   int result;
69419
69420   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
69421   jresult = (int)result;
69422   return jresult;
69423 }
69424
69425
69426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
69427   int jresult ;
69428   int result;
69429
69430   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
69431   jresult = (int)result;
69432   return jresult;
69433 }
69434
69435
69436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
69437   int jresult ;
69438   int result;
69439
69440   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
69441   jresult = (int)result;
69442   return jresult;
69443 }
69444
69445
69446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
69447   int jresult ;
69448   int result;
69449
69450   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
69451   jresult = (int)result;
69452   return jresult;
69453 }
69454
69455
69456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
69457   int jresult ;
69458   int result;
69459
69460   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
69461   jresult = (int)result;
69462   return jresult;
69463 }
69464
69465
69466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
69467   int jresult ;
69468   int result;
69469
69470   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
69471   jresult = (int)result;
69472   return jresult;
69473 }
69474
69475
69476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
69477   void * jresult ;
69478   Dali::Toolkit::ItemView::Property *result = 0 ;
69479
69480   {
69481     try {
69482       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
69483     } catch (std::out_of_range& e) {
69484       {
69485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69486       };
69487     } catch (std::exception& e) {
69488       {
69489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69490       };
69491     } catch (...) {
69492       {
69493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69494       };
69495     }
69496   }
69497   jresult = (void *)result;
69498   return jresult;
69499 }
69500
69501
69502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
69503   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
69504
69505   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
69506   {
69507     try {
69508       delete arg1;
69509     } catch (std::out_of_range& e) {
69510       {
69511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69512       };
69513     } catch (std::exception& e) {
69514       {
69515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69516       };
69517     } catch (...) {
69518       {
69519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69520       };
69521     }
69522   }
69523 }
69524
69525
69526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
69527   void * jresult ;
69528   Dali::Toolkit::ItemView *result = 0 ;
69529
69530   {
69531     try {
69532       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
69533     } catch (std::out_of_range& e) {
69534       {
69535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69536       };
69537     } catch (std::exception& e) {
69538       {
69539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69540       };
69541     } catch (...) {
69542       {
69543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69544       };
69545     }
69546   }
69547   jresult = (void *)result;
69548   return jresult;
69549 }
69550
69551
69552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
69553   void * jresult ;
69554   Dali::Toolkit::ItemView *arg1 = 0 ;
69555   Dali::Toolkit::ItemView *result = 0 ;
69556
69557   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69558   if (!arg1) {
69559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69560     return 0;
69561   }
69562   {
69563     try {
69564       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
69565     } catch (std::out_of_range& e) {
69566       {
69567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69568       };
69569     } catch (std::exception& e) {
69570       {
69571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69572       };
69573     } catch (...) {
69574       {
69575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69576       };
69577     }
69578   }
69579   jresult = (void *)result;
69580   return jresult;
69581 }
69582
69583
69584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
69585   void * jresult ;
69586   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69587   Dali::Toolkit::ItemView *arg2 = 0 ;
69588   Dali::Toolkit::ItemView *result = 0 ;
69589
69590   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69591   arg2 = (Dali::Toolkit::ItemView *)jarg2;
69592   if (!arg2) {
69593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69594     return 0;
69595   }
69596   {
69597     try {
69598       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
69599     } catch (std::out_of_range& e) {
69600       {
69601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69602       };
69603     } catch (std::exception& e) {
69604       {
69605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69606       };
69607     } catch (...) {
69608       {
69609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69610       };
69611     }
69612   }
69613   jresult = (void *)result;
69614   return jresult;
69615 }
69616
69617
69618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
69619   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69620
69621   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69622   {
69623     try {
69624       delete arg1;
69625     } catch (std::out_of_range& e) {
69626       {
69627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69628       };
69629     } catch (std::exception& e) {
69630       {
69631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69632       };
69633     } catch (...) {
69634       {
69635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69636       };
69637     }
69638   }
69639 }
69640
69641
69642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
69643   void * jresult ;
69644   Dali::Toolkit::ItemFactory *arg1 = 0 ;
69645   Dali::Toolkit::ItemView result;
69646
69647   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69648   if (!arg1) {
69649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
69650     return 0;
69651   }
69652   {
69653     try {
69654       result = Dali::Toolkit::ItemView::New(*arg1);
69655     } catch (std::out_of_range& e) {
69656       {
69657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69658       };
69659     } catch (std::exception& e) {
69660       {
69661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69662       };
69663     } catch (...) {
69664       {
69665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69666       };
69667     }
69668   }
69669   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69670   return jresult;
69671 }
69672
69673
69674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
69675   void * jresult ;
69676   Dali::BaseHandle arg1 ;
69677   Dali::BaseHandle *argp1 ;
69678   Dali::Toolkit::ItemView result;
69679
69680   argp1 = (Dali::BaseHandle *)jarg1;
69681   if (!argp1) {
69682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69683     return 0;
69684   }
69685   arg1 = *argp1;
69686   {
69687     try {
69688       result = Dali::Toolkit::ItemView::DownCast(arg1);
69689     } catch (std::out_of_range& e) {
69690       {
69691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69692       };
69693     } catch (std::exception& e) {
69694       {
69695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69696       };
69697     } catch (...) {
69698       {
69699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69700       };
69701     }
69702   }
69703   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69704   return jresult;
69705 }
69706
69707
69708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
69709   unsigned int jresult ;
69710   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69711   unsigned int result;
69712
69713   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69714   {
69715     try {
69716       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
69717     } catch (std::out_of_range& e) {
69718       {
69719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69720       };
69721     } catch (std::exception& e) {
69722       {
69723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69724       };
69725     } catch (...) {
69726       {
69727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69728       };
69729     }
69730   }
69731   jresult = result;
69732   return jresult;
69733 }
69734
69735
69736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
69737   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69738   Dali::Toolkit::ItemLayout *arg2 = 0 ;
69739
69740   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69741   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
69742   if (!arg2) {
69743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
69744     return ;
69745   }
69746   {
69747     try {
69748       (arg1)->AddLayout(*arg2);
69749     } catch (std::out_of_range& e) {
69750       {
69751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69752       };
69753     } catch (std::exception& e) {
69754       {
69755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69756       };
69757     } catch (...) {
69758       {
69759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69760       };
69761     }
69762   }
69763 }
69764
69765
69766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
69767   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69768   unsigned int arg2 ;
69769
69770   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69771   arg2 = (unsigned int)jarg2;
69772   {
69773     try {
69774       (arg1)->RemoveLayout(arg2);
69775     } catch (std::out_of_range& e) {
69776       {
69777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69778       };
69779     } catch (std::exception& e) {
69780       {
69781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69782       };
69783     } catch (...) {
69784       {
69785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69786       };
69787     }
69788   }
69789 }
69790
69791
69792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
69793   void * jresult ;
69794   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69795   unsigned int arg2 ;
69796   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69797
69798   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69799   arg2 = (unsigned int)jarg2;
69800   {
69801     try {
69802       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
69803     } catch (std::out_of_range& e) {
69804       {
69805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69806       };
69807     } catch (std::exception& e) {
69808       {
69809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69810       };
69811     } catch (...) {
69812       {
69813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69814       };
69815     }
69816   }
69817   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69818   return jresult;
69819 }
69820
69821
69822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
69823   void * jresult ;
69824   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69825   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69826
69827   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69828   {
69829     try {
69830       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
69831     } catch (std::out_of_range& e) {
69832       {
69833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69834       };
69835     } catch (std::exception& e) {
69836       {
69837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69838       };
69839     } catch (...) {
69840       {
69841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69842       };
69843     }
69844   }
69845   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69846   return jresult;
69847 }
69848
69849
69850 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
69851   float jresult ;
69852   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69853   Dali::Toolkit::ItemId arg2 ;
69854   float result;
69855
69856   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69857   arg2 = (Dali::Toolkit::ItemId)jarg2;
69858   {
69859     try {
69860       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
69861     } catch (std::out_of_range& e) {
69862       {
69863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69864       };
69865     } catch (std::exception& e) {
69866       {
69867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69868       };
69869     } catch (...) {
69870       {
69871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69872       };
69873     }
69874   }
69875   jresult = result;
69876   return jresult;
69877 }
69878
69879
69880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
69881   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69882   unsigned int arg2 ;
69883   Dali::Vector3 arg3 ;
69884   float arg4 ;
69885   Dali::Vector3 *argp3 ;
69886
69887   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69888   arg2 = (unsigned int)jarg2;
69889   argp3 = (Dali::Vector3 *)jarg3;
69890   if (!argp3) {
69891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69892     return ;
69893   }
69894   arg3 = *argp3;
69895   arg4 = (float)jarg4;
69896   {
69897     try {
69898       (arg1)->ActivateLayout(arg2,arg3,arg4);
69899     } catch (std::out_of_range& e) {
69900       {
69901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69902       };
69903     } catch (std::exception& e) {
69904       {
69905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69906       };
69907     } catch (...) {
69908       {
69909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69910       };
69911     }
69912   }
69913 }
69914
69915
69916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
69917   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69918
69919   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69920   {
69921     try {
69922       (arg1)->DeactivateCurrentLayout();
69923     } catch (std::out_of_range& e) {
69924       {
69925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69926       };
69927     } catch (std::exception& e) {
69928       {
69929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69930       };
69931     } catch (...) {
69932       {
69933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69934       };
69935     }
69936   }
69937 }
69938
69939
69940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
69941   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69942   float arg2 ;
69943
69944   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69945   arg2 = (float)jarg2;
69946   {
69947     try {
69948       (arg1)->SetMinimumSwipeSpeed(arg2);
69949     } catch (std::out_of_range& e) {
69950       {
69951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69952       };
69953     } catch (std::exception& e) {
69954       {
69955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69956       };
69957     } catch (...) {
69958       {
69959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69960       };
69961     }
69962   }
69963 }
69964
69965
69966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
69967   float jresult ;
69968   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69969   float result;
69970
69971   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69972   {
69973     try {
69974       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
69975     } catch (std::out_of_range& e) {
69976       {
69977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69978       };
69979     } catch (std::exception& e) {
69980       {
69981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69982       };
69983     } catch (...) {
69984       {
69985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69986       };
69987     }
69988   }
69989   jresult = result;
69990   return jresult;
69991 }
69992
69993
69994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
69995   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69996   float arg2 ;
69997
69998   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69999   arg2 = (float)jarg2;
70000   {
70001     try {
70002       (arg1)->SetMinimumSwipeDistance(arg2);
70003     } catch (std::out_of_range& e) {
70004       {
70005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70006       };
70007     } catch (std::exception& e) {
70008       {
70009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70010       };
70011     } catch (...) {
70012       {
70013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70014       };
70015     }
70016   }
70017 }
70018
70019
70020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70021   float jresult ;
70022   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70023   float result;
70024
70025   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70026   {
70027     try {
70028       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70029     } catch (std::out_of_range& e) {
70030       {
70031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70032       };
70033     } catch (std::exception& e) {
70034       {
70035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70036       };
70037     } catch (...) {
70038       {
70039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70040       };
70041     }
70042   }
70043   jresult = result;
70044   return jresult;
70045 }
70046
70047
70048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
70049   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70050   float arg2 ;
70051
70052   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70053   arg2 = (float)jarg2;
70054   {
70055     try {
70056       (arg1)->SetWheelScrollDistanceStep(arg2);
70057     } catch (std::out_of_range& e) {
70058       {
70059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70060       };
70061     } catch (std::exception& e) {
70062       {
70063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70064       };
70065     } catch (...) {
70066       {
70067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70068       };
70069     }
70070   }
70071 }
70072
70073
70074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
70075   float jresult ;
70076   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70077   float result;
70078
70079   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70080   {
70081     try {
70082       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
70083     } catch (std::out_of_range& e) {
70084       {
70085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70086       };
70087     } catch (std::exception& e) {
70088       {
70089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70090       };
70091     } catch (...) {
70092       {
70093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70094       };
70095     }
70096   }
70097   jresult = result;
70098   return jresult;
70099 }
70100
70101
70102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
70103   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70104   bool arg2 ;
70105
70106   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70107   arg2 = jarg2 ? true : false;
70108   {
70109     try {
70110       (arg1)->SetAnchoring(arg2);
70111     } catch (std::out_of_range& e) {
70112       {
70113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70114       };
70115     } catch (std::exception& e) {
70116       {
70117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70118       };
70119     } catch (...) {
70120       {
70121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70122       };
70123     }
70124   }
70125 }
70126
70127
70128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
70129   unsigned int jresult ;
70130   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70131   bool result;
70132
70133   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70134   {
70135     try {
70136       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
70137     } catch (std::out_of_range& e) {
70138       {
70139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70140       };
70141     } catch (std::exception& e) {
70142       {
70143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70144       };
70145     } catch (...) {
70146       {
70147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70148       };
70149     }
70150   }
70151   jresult = result;
70152   return jresult;
70153 }
70154
70155
70156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
70157   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70158   float arg2 ;
70159
70160   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70161   arg2 = (float)jarg2;
70162   {
70163     try {
70164       (arg1)->SetAnchoringDuration(arg2);
70165     } catch (std::out_of_range& e) {
70166       {
70167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70168       };
70169     } catch (std::exception& e) {
70170       {
70171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70172       };
70173     } catch (...) {
70174       {
70175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70176       };
70177     }
70178   }
70179 }
70180
70181
70182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
70183   float jresult ;
70184   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70185   float result;
70186
70187   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70188   {
70189     try {
70190       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
70191     } catch (std::out_of_range& e) {
70192       {
70193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70194       };
70195     } catch (std::exception& e) {
70196       {
70197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70198       };
70199     } catch (...) {
70200       {
70201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70202       };
70203     }
70204   }
70205   jresult = result;
70206   return jresult;
70207 }
70208
70209
70210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
70211   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70212   Dali::Toolkit::ItemId arg2 ;
70213   float arg3 ;
70214
70215   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70216   arg2 = (Dali::Toolkit::ItemId)jarg2;
70217   arg3 = (float)jarg3;
70218   {
70219     try {
70220       (arg1)->ScrollToItem(arg2,arg3);
70221     } catch (std::out_of_range& e) {
70222       {
70223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70224       };
70225     } catch (std::exception& e) {
70226       {
70227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70228       };
70229     } catch (...) {
70230       {
70231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70232       };
70233     }
70234   }
70235 }
70236
70237
70238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
70239   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70240   float arg2 ;
70241
70242   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70243   arg2 = (float)jarg2;
70244   {
70245     try {
70246       (arg1)->SetRefreshInterval(arg2);
70247     } catch (std::out_of_range& e) {
70248       {
70249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70250       };
70251     } catch (std::exception& e) {
70252       {
70253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70254       };
70255     } catch (...) {
70256       {
70257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70258       };
70259     }
70260   }
70261 }
70262
70263
70264 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
70265   float jresult ;
70266   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70267   float result;
70268
70269   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70270   {
70271     try {
70272       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
70273     } catch (std::out_of_range& e) {
70274       {
70275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70276       };
70277     } catch (std::exception& e) {
70278       {
70279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70280       };
70281     } catch (...) {
70282       {
70283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70284       };
70285     }
70286   }
70287   jresult = result;
70288   return jresult;
70289 }
70290
70291
70292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
70293   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70294
70295   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70296   {
70297     try {
70298       (arg1)->Refresh();
70299     } catch (std::out_of_range& e) {
70300       {
70301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70302       };
70303     } catch (std::exception& e) {
70304       {
70305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70306       };
70307     } catch (...) {
70308       {
70309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70310       };
70311     }
70312   }
70313 }
70314
70315
70316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
70317   void * jresult ;
70318   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70319   Dali::Toolkit::ItemId arg2 ;
70320   Dali::Actor result;
70321
70322   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70323   arg2 = (Dali::Toolkit::ItemId)jarg2;
70324   {
70325     try {
70326       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
70327     } catch (std::out_of_range& e) {
70328       {
70329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70330       };
70331     } catch (std::exception& e) {
70332       {
70333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70334       };
70335     } catch (...) {
70336       {
70337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70338       };
70339     }
70340   }
70341   jresult = new Dali::Actor((const Dali::Actor &)result);
70342   return jresult;
70343 }
70344
70345
70346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
70347   unsigned int jresult ;
70348   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70349   Dali::Actor arg2 ;
70350   Dali::Actor *argp2 ;
70351   Dali::Toolkit::ItemId result;
70352
70353   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70354   argp2 = (Dali::Actor *)jarg2;
70355   if (!argp2) {
70356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70357     return 0;
70358   }
70359   arg2 = *argp2;
70360   {
70361     try {
70362       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
70363     } catch (std::out_of_range& e) {
70364       {
70365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70366       };
70367     } catch (std::exception& e) {
70368       {
70369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70370       };
70371     } catch (...) {
70372       {
70373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70374       };
70375     }
70376   }
70377   jresult = result;
70378   return jresult;
70379 }
70380
70381
70382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
70383   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70384   Dali::Toolkit::Item arg2 ;
70385   float arg3 ;
70386   Dali::Toolkit::Item *argp2 ;
70387
70388   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70389   argp2 = (Dali::Toolkit::Item *)jarg2;
70390   if (!argp2) {
70391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70392     return ;
70393   }
70394   arg2 = *argp2;
70395   arg3 = (float)jarg3;
70396   {
70397     try {
70398       (arg1)->InsertItem(arg2,arg3);
70399     } catch (std::out_of_range& e) {
70400       {
70401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70402       };
70403     } catch (std::exception& e) {
70404       {
70405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70406       };
70407     } catch (...) {
70408       {
70409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70410       };
70411     }
70412   }
70413 }
70414
70415
70416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
70417   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70418   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70419   float arg3 ;
70420
70421   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70422   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70423   if (!arg2) {
70424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70425     return ;
70426   }
70427   arg3 = (float)jarg3;
70428   {
70429     try {
70430       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70431     } catch (std::out_of_range& e) {
70432       {
70433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70434       };
70435     } catch (std::exception& e) {
70436       {
70437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70438       };
70439     } catch (...) {
70440       {
70441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70442       };
70443     }
70444   }
70445 }
70446
70447
70448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
70449   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70450   Dali::Toolkit::ItemId arg2 ;
70451   float arg3 ;
70452
70453   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70454   arg2 = (Dali::Toolkit::ItemId)jarg2;
70455   arg3 = (float)jarg3;
70456   {
70457     try {
70458       (arg1)->RemoveItem(arg2,arg3);
70459     } catch (std::out_of_range& e) {
70460       {
70461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70462       };
70463     } catch (std::exception& e) {
70464       {
70465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70466       };
70467     } catch (...) {
70468       {
70469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70470       };
70471     }
70472   }
70473 }
70474
70475
70476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
70477   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70478   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
70479   float arg3 ;
70480
70481   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70482   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
70483   if (!arg2) {
70484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
70485     return ;
70486   }
70487   arg3 = (float)jarg3;
70488   {
70489     try {
70490       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
70491     } catch (std::out_of_range& e) {
70492       {
70493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70494       };
70495     } catch (std::exception& e) {
70496       {
70497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70498       };
70499     } catch (...) {
70500       {
70501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70502       };
70503     }
70504   }
70505 }
70506
70507
70508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
70509   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70510   Dali::Toolkit::Item arg2 ;
70511   float arg3 ;
70512   Dali::Toolkit::Item *argp2 ;
70513
70514   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70515   argp2 = (Dali::Toolkit::Item *)jarg2;
70516   if (!argp2) {
70517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70518     return ;
70519   }
70520   arg2 = *argp2;
70521   arg3 = (float)jarg3;
70522   {
70523     try {
70524       (arg1)->ReplaceItem(arg2,arg3);
70525     } catch (std::out_of_range& e) {
70526       {
70527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70528       };
70529     } catch (std::exception& e) {
70530       {
70531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70532       };
70533     } catch (...) {
70534       {
70535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70536       };
70537     }
70538   }
70539 }
70540
70541
70542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
70543   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70544   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70545   float arg3 ;
70546
70547   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70548   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70549   if (!arg2) {
70550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70551     return ;
70552   }
70553   arg3 = (float)jarg3;
70554   {
70555     try {
70556       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70557     } catch (std::out_of_range& e) {
70558       {
70559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70560       };
70561     } catch (std::exception& e) {
70562       {
70563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70564       };
70565     } catch (...) {
70566       {
70567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70568       };
70569     }
70570   }
70571 }
70572
70573
70574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
70575   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70576   Dali::Vector3 *arg2 = 0 ;
70577
70578   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70579   arg2 = (Dali::Vector3 *)jarg2;
70580   if (!arg2) {
70581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70582     return ;
70583   }
70584   {
70585     try {
70586       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
70587     } catch (std::out_of_range& e) {
70588       {
70589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70590       };
70591     } catch (std::exception& e) {
70592       {
70593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70594       };
70595     } catch (...) {
70596       {
70597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70598       };
70599     }
70600   }
70601 }
70602
70603
70604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
70605   void * jresult ;
70606   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70607   Dali::Vector3 result;
70608
70609   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70610   {
70611     try {
70612       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
70613     } catch (std::out_of_range& e) {
70614       {
70615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70616       };
70617     } catch (std::exception& e) {
70618       {
70619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70620       };
70621     } catch (...) {
70622       {
70623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70624       };
70625     }
70626   }
70627   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70628   return jresult;
70629 }
70630
70631
70632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
70633   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70634   Dali::Vector3 *arg2 = 0 ;
70635
70636   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70637   arg2 = (Dali::Vector3 *)jarg2;
70638   if (!arg2) {
70639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70640     return ;
70641   }
70642   {
70643     try {
70644       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
70645     } catch (std::out_of_range& e) {
70646       {
70647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70648       };
70649     } catch (std::exception& e) {
70650       {
70651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70652       };
70653     } catch (...) {
70654       {
70655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70656       };
70657     }
70658   }
70659 }
70660
70661
70662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
70663   void * jresult ;
70664   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70665   Dali::Vector3 result;
70666
70667   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70668   {
70669     try {
70670       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
70671     } catch (std::out_of_range& e) {
70672       {
70673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70674       };
70675     } catch (std::exception& e) {
70676       {
70677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70678       };
70679     } catch (...) {
70680       {
70681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70682       };
70683     }
70684   }
70685   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70686   return jresult;
70687 }
70688
70689
70690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
70691   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70692   Dali::Toolkit::ItemRange *arg2 = 0 ;
70693
70694   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70695   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
70696   if (!arg2) {
70697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
70698     return ;
70699   }
70700   {
70701     try {
70702       (arg1)->GetItemsRange(*arg2);
70703     } catch (std::out_of_range& e) {
70704       {
70705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70706       };
70707     } catch (std::exception& e) {
70708       {
70709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70710       };
70711     } catch (...) {
70712       {
70713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70714       };
70715     }
70716   }
70717 }
70718
70719
70720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
70721   void * jresult ;
70722   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70723   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
70724
70725   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70726   {
70727     try {
70728       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
70729     } catch (std::out_of_range& e) {
70730       {
70731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70732       };
70733     } catch (std::exception& e) {
70734       {
70735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70736       };
70737     } catch (...) {
70738       {
70739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70740       };
70741     }
70742   }
70743   jresult = (void *)result;
70744   return jresult;
70745 }
70746
70747
70748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
70749   Dali::Vector3 *arg1 = 0 ;
70750   PropertyInputContainer *arg2 = 0 ;
70751
70752   arg1 = (Dali::Vector3 *)jarg1;
70753   if (!arg1) {
70754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70755     return ;
70756   }
70757   arg2 = (PropertyInputContainer *)jarg2;
70758   if (!arg2) {
70759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70760     return ;
70761   }
70762   {
70763     try {
70764       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70765     } catch (std::out_of_range& e) {
70766       {
70767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70768       };
70769     } catch (std::exception& e) {
70770       {
70771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70772       };
70773     } catch (...) {
70774       {
70775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70776       };
70777     }
70778   }
70779 }
70780
70781
70782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
70783   Dali::Vector3 *arg1 = 0 ;
70784   PropertyInputContainer *arg2 = 0 ;
70785
70786   arg1 = (Dali::Vector3 *)jarg1;
70787   if (!arg1) {
70788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70789     return ;
70790   }
70791   arg2 = (PropertyInputContainer *)jarg2;
70792   if (!arg2) {
70793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
70794     return ;
70795   }
70796   {
70797     try {
70798       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
70799     } catch (std::out_of_range& e) {
70800       {
70801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70802       };
70803     } catch (std::exception& e) {
70804       {
70805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70806       };
70807     } catch (...) {
70808       {
70809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70810       };
70811     }
70812   }
70813 }
70814
70815
70816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
70817   void * jresult ;
70818   Dali::Toolkit::ScrollViewEffect *result = 0 ;
70819
70820   {
70821     try {
70822       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
70823     } catch (std::out_of_range& e) {
70824       {
70825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70826       };
70827     } catch (std::exception& e) {
70828       {
70829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70830       };
70831     } catch (...) {
70832       {
70833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70834       };
70835     }
70836   }
70837   jresult = (void *)result;
70838   return jresult;
70839 }
70840
70841
70842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
70843   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
70844
70845   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
70846   {
70847     try {
70848       delete arg1;
70849     } catch (std::out_of_range& e) {
70850       {
70851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70852       };
70853     } catch (std::exception& e) {
70854       {
70855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70856       };
70857     } catch (...) {
70858       {
70859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70860       };
70861     }
70862   }
70863 }
70864
70865
70866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
70867   void * jresult ;
70868   Dali::Path arg1 ;
70869   Dali::Vector3 *arg2 = 0 ;
70870   Dali::Property::Index arg3 ;
70871   Dali::Vector3 *arg4 = 0 ;
70872   unsigned int arg5 ;
70873   Dali::Path *argp1 ;
70874   Dali::Toolkit::ScrollViewPagePathEffect result;
70875
70876   argp1 = (Dali::Path *)jarg1;
70877   if (!argp1) {
70878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
70879     return 0;
70880   }
70881   arg1 = *argp1;
70882   arg2 = (Dali::Vector3 *)jarg2;
70883   if (!arg2) {
70884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70885     return 0;
70886   }
70887   arg3 = (Dali::Property::Index)jarg3;
70888   arg4 = (Dali::Vector3 *)jarg4;
70889   if (!arg4) {
70890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70891     return 0;
70892   }
70893   arg5 = (unsigned int)jarg5;
70894   {
70895     try {
70896       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
70897     } catch (std::out_of_range& e) {
70898       {
70899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70900       };
70901     } catch (std::exception& e) {
70902       {
70903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70904       };
70905     } catch (...) {
70906       {
70907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70908       };
70909     }
70910   }
70911   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
70912   return jresult;
70913 }
70914
70915
70916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
70917   void * jresult ;
70918   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
70919
70920   {
70921     try {
70922       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
70923     } catch (std::out_of_range& e) {
70924       {
70925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70926       };
70927     } catch (std::exception& e) {
70928       {
70929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70930       };
70931     } catch (...) {
70932       {
70933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70934       };
70935     }
70936   }
70937   jresult = (void *)result;
70938   return jresult;
70939 }
70940
70941
70942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
70943   void * jresult ;
70944   Dali::BaseHandle arg1 ;
70945   Dali::BaseHandle *argp1 ;
70946   Dali::Toolkit::ScrollViewPagePathEffect result;
70947
70948   argp1 = (Dali::BaseHandle *)jarg1;
70949   if (!argp1) {
70950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70951     return 0;
70952   }
70953   arg1 = *argp1;
70954   {
70955     try {
70956       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
70957     } catch (std::out_of_range& e) {
70958       {
70959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70960       };
70961     } catch (std::exception& e) {
70962       {
70963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70964       };
70965     } catch (...) {
70966       {
70967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70968       };
70969     }
70970   }
70971   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
70972   return jresult;
70973 }
70974
70975
70976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
70977   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
70978   Dali::Actor arg2 ;
70979   unsigned int arg3 ;
70980   Dali::Actor *argp2 ;
70981
70982   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
70983   argp2 = (Dali::Actor *)jarg2;
70984   if (!argp2) {
70985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70986     return ;
70987   }
70988   arg2 = *argp2;
70989   arg3 = (unsigned int)jarg3;
70990   {
70991     try {
70992       (arg1)->ApplyToPage(arg2,arg3);
70993     } catch (std::out_of_range& e) {
70994       {
70995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70996       };
70997     } catch (std::exception& e) {
70998       {
70999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71000       };
71001     } catch (...) {
71002       {
71003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71004       };
71005     }
71006   }
71007 }
71008
71009
71010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
71011   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71012
71013   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71014   {
71015     try {
71016       delete arg1;
71017     } catch (std::out_of_range& e) {
71018       {
71019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71020       };
71021     } catch (std::exception& e) {
71022       {
71023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71024       };
71025     } catch (...) {
71026       {
71027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71028       };
71029     }
71030   }
71031 }
71032
71033
71034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
71035   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71036   Dali::Toolkit::ClampState arg2 ;
71037
71038   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71039   arg2 = (Dali::Toolkit::ClampState)jarg2;
71040   if (arg1) (arg1)->x = arg2;
71041 }
71042
71043
71044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
71045   int jresult ;
71046   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71047   Dali::Toolkit::ClampState result;
71048
71049   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71050   result = (Dali::Toolkit::ClampState) ((arg1)->x);
71051   jresult = (int)result;
71052   return jresult;
71053 }
71054
71055
71056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
71057   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71058   Dali::Toolkit::ClampState arg2 ;
71059
71060   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71061   arg2 = (Dali::Toolkit::ClampState)jarg2;
71062   if (arg1) (arg1)->y = arg2;
71063 }
71064
71065
71066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
71067   int jresult ;
71068   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71069   Dali::Toolkit::ClampState result;
71070
71071   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71072   result = (Dali::Toolkit::ClampState) ((arg1)->y);
71073   jresult = (int)result;
71074   return jresult;
71075 }
71076
71077
71078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
71079   void * jresult ;
71080   Dali::Toolkit::ClampState2D *result = 0 ;
71081
71082   {
71083     try {
71084       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
71085     } catch (std::out_of_range& e) {
71086       {
71087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71088       };
71089     } catch (std::exception& e) {
71090       {
71091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71092       };
71093     } catch (...) {
71094       {
71095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71096       };
71097     }
71098   }
71099   jresult = (void *)result;
71100   return jresult;
71101 }
71102
71103
71104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
71105   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71106
71107   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71108   {
71109     try {
71110       delete arg1;
71111     } catch (std::out_of_range& e) {
71112       {
71113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71114       };
71115     } catch (std::exception& e) {
71116       {
71117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71118       };
71119     } catch (...) {
71120       {
71121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71122       };
71123     }
71124   }
71125 }
71126
71127
71128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
71129   void * jresult ;
71130   float arg1 ;
71131   float arg2 ;
71132   bool arg3 ;
71133   Dali::Toolkit::RulerDomain *result = 0 ;
71134
71135   arg1 = (float)jarg1;
71136   arg2 = (float)jarg2;
71137   arg3 = jarg3 ? true : false;
71138   {
71139     try {
71140       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
71141     } catch (std::out_of_range& e) {
71142       {
71143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71144       };
71145     } catch (std::exception& e) {
71146       {
71147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71148       };
71149     } catch (...) {
71150       {
71151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71152       };
71153     }
71154   }
71155   jresult = (void *)result;
71156   return jresult;
71157 }
71158
71159
71160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
71161   void * jresult ;
71162   float arg1 ;
71163   float arg2 ;
71164   Dali::Toolkit::RulerDomain *result = 0 ;
71165
71166   arg1 = (float)jarg1;
71167   arg2 = (float)jarg2;
71168   {
71169     try {
71170       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
71171     } catch (std::out_of_range& e) {
71172       {
71173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71174       };
71175     } catch (std::exception& e) {
71176       {
71177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71178       };
71179     } catch (...) {
71180       {
71181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71182       };
71183     }
71184   }
71185   jresult = (void *)result;
71186   return jresult;
71187 }
71188
71189
71190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
71191   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71192   float arg2 ;
71193
71194   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71195   arg2 = (float)jarg2;
71196   if (arg1) (arg1)->min = arg2;
71197 }
71198
71199
71200 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
71201   float jresult ;
71202   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71203   float result;
71204
71205   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71206   result = (float) ((arg1)->min);
71207   jresult = result;
71208   return jresult;
71209 }
71210
71211
71212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
71213   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71214   float arg2 ;
71215
71216   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71217   arg2 = (float)jarg2;
71218   if (arg1) (arg1)->max = arg2;
71219 }
71220
71221
71222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
71223   float jresult ;
71224   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71225   float result;
71226
71227   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71228   result = (float) ((arg1)->max);
71229   jresult = result;
71230   return jresult;
71231 }
71232
71233
71234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
71235   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71236   bool arg2 ;
71237
71238   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71239   arg2 = jarg2 ? true : false;
71240   if (arg1) (arg1)->enabled = arg2;
71241 }
71242
71243
71244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
71245   unsigned int jresult ;
71246   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71247   bool result;
71248
71249   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71250   result = (bool) ((arg1)->enabled);
71251   jresult = result;
71252   return jresult;
71253 }
71254
71255
71256 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71257   float jresult ;
71258   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71259   float arg2 ;
71260   float arg3 ;
71261   float arg4 ;
71262   float result;
71263
71264   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71265   arg2 = (float)jarg2;
71266   arg3 = (float)jarg3;
71267   arg4 = (float)jarg4;
71268   {
71269     try {
71270       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
71271     } catch (std::out_of_range& e) {
71272       {
71273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71274       };
71275     } catch (std::exception& e) {
71276       {
71277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71278       };
71279     } catch (...) {
71280       {
71281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71282       };
71283     }
71284   }
71285   jresult = result;
71286   return jresult;
71287 }
71288
71289
71290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71291   float jresult ;
71292   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71293   float arg2 ;
71294   float arg3 ;
71295   float result;
71296
71297   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71298   arg2 = (float)jarg2;
71299   arg3 = (float)jarg3;
71300   {
71301     try {
71302       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
71303     } catch (std::out_of_range& e) {
71304       {
71305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71306       };
71307     } catch (std::exception& e) {
71308       {
71309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71310       };
71311     } catch (...) {
71312       {
71313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71314       };
71315     }
71316   }
71317   jresult = result;
71318   return jresult;
71319 }
71320
71321
71322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
71323   float jresult ;
71324   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71325   float arg2 ;
71326   float result;
71327
71328   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71329   arg2 = (float)jarg2;
71330   {
71331     try {
71332       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
71333     } catch (std::out_of_range& e) {
71334       {
71335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71336       };
71337     } catch (std::exception& e) {
71338       {
71339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71340       };
71341     } catch (...) {
71342       {
71343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71344       };
71345     }
71346   }
71347   jresult = result;
71348   return jresult;
71349 }
71350
71351
71352 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71353   float jresult ;
71354   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71355   float arg2 ;
71356   float arg3 ;
71357   float arg4 ;
71358   Dali::Toolkit::ClampState *arg5 = 0 ;
71359   float result;
71360
71361   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71362   arg2 = (float)jarg2;
71363   arg3 = (float)jarg3;
71364   arg4 = (float)jarg4;
71365   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71366   if (!arg5) {
71367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71368     return 0;
71369   }
71370   {
71371     try {
71372       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71373     } catch (std::out_of_range& e) {
71374       {
71375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71376       };
71377     } catch (std::exception& e) {
71378       {
71379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71380       };
71381     } catch (...) {
71382       {
71383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71384       };
71385     }
71386   }
71387   jresult = result;
71388   return jresult;
71389 }
71390
71391
71392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
71393   float jresult ;
71394   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71395   float result;
71396
71397   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71398   {
71399     try {
71400       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
71401     } catch (std::out_of_range& e) {
71402       {
71403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71404       };
71405     } catch (std::exception& e) {
71406       {
71407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71408       };
71409     } catch (...) {
71410       {
71411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71412       };
71413     }
71414   }
71415   jresult = result;
71416   return jresult;
71417 }
71418
71419
71420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
71421   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71422
71423   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71424   {
71425     try {
71426       delete arg1;
71427     } catch (std::out_of_range& e) {
71428       {
71429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71430       };
71431     } catch (std::exception& e) {
71432       {
71433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71434       };
71435     } catch (...) {
71436       {
71437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71438       };
71439     }
71440   }
71441 }
71442
71443
71444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
71445   float jresult ;
71446   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71447   float arg2 ;
71448   float arg3 ;
71449   float result;
71450
71451   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71452   arg2 = (float)jarg2;
71453   arg3 = (float)jarg3;
71454   {
71455     try {
71456       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
71457     } catch (std::out_of_range& e) {
71458       {
71459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71460       };
71461     } catch (std::exception& e) {
71462       {
71463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71464       };
71465     } catch (...) {
71466       {
71467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71468       };
71469     }
71470   }
71471   jresult = result;
71472   return jresult;
71473 }
71474
71475
71476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
71477   float jresult ;
71478   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71479   float arg2 ;
71480   float result;
71481
71482   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71483   arg2 = (float)jarg2;
71484   {
71485     try {
71486       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
71487     } catch (std::out_of_range& e) {
71488       {
71489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71490       };
71491     } catch (std::exception& e) {
71492       {
71493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71494       };
71495     } catch (...) {
71496       {
71497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71498       };
71499     }
71500   }
71501   jresult = result;
71502   return jresult;
71503 }
71504
71505
71506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
71507   float jresult ;
71508   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71509   unsigned int arg2 ;
71510   unsigned int *arg3 = 0 ;
71511   bool arg4 ;
71512   float result;
71513
71514   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71515   arg2 = (unsigned int)jarg2;
71516   arg3 = (unsigned int *)jarg3;
71517   arg4 = jarg4 ? true : false;
71518   {
71519     try {
71520       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
71521     } catch (std::out_of_range& e) {
71522       {
71523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71524       };
71525     } catch (std::exception& e) {
71526       {
71527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71528       };
71529     } catch (...) {
71530       {
71531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71532       };
71533     }
71534   }
71535   jresult = result;
71536   return jresult;
71537 }
71538
71539
71540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
71541   unsigned int jresult ;
71542   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71543   float arg2 ;
71544   bool arg3 ;
71545   unsigned int result;
71546
71547   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71548   arg2 = (float)jarg2;
71549   arg3 = jarg3 ? true : false;
71550   {
71551     try {
71552       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
71553     } catch (std::out_of_range& e) {
71554       {
71555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71556       };
71557     } catch (std::exception& e) {
71558       {
71559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71560       };
71561     } catch (...) {
71562       {
71563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71564       };
71565     }
71566   }
71567   jresult = result;
71568   return jresult;
71569 }
71570
71571
71572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
71573   unsigned int jresult ;
71574   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71575   unsigned int result;
71576
71577   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71578   {
71579     try {
71580       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
71581     } catch (std::out_of_range& e) {
71582       {
71583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71584       };
71585     } catch (std::exception& e) {
71586       {
71587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71588       };
71589     } catch (...) {
71590       {
71591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71592       };
71593     }
71594   }
71595   jresult = result;
71596   return jresult;
71597 }
71598
71599
71600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
71601   int jresult ;
71602   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71603   Dali::Toolkit::Ruler::RulerType result;
71604
71605   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71606   {
71607     try {
71608       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
71609     } catch (std::out_of_range& e) {
71610       {
71611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71612       };
71613     } catch (std::exception& e) {
71614       {
71615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71616       };
71617     } catch (...) {
71618       {
71619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71620       };
71621     }
71622   }
71623   jresult = (int)result;
71624   return jresult;
71625 }
71626
71627
71628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
71629   unsigned int jresult ;
71630   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71631   bool result;
71632
71633   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71634   {
71635     try {
71636       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
71637     } catch (std::out_of_range& e) {
71638       {
71639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71640       };
71641     } catch (std::exception& e) {
71642       {
71643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71644       };
71645     } catch (...) {
71646       {
71647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71648       };
71649     }
71650   }
71651   jresult = result;
71652   return jresult;
71653 }
71654
71655
71656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
71657   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71658
71659   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71660   {
71661     try {
71662       (arg1)->Enable();
71663     } catch (std::out_of_range& e) {
71664       {
71665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71666       };
71667     } catch (std::exception& e) {
71668       {
71669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71670       };
71671     } catch (...) {
71672       {
71673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71674       };
71675     }
71676   }
71677 }
71678
71679
71680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
71681   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71682
71683   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71684   {
71685     try {
71686       (arg1)->Disable();
71687     } catch (std::out_of_range& e) {
71688       {
71689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71690       };
71691     } catch (std::exception& e) {
71692       {
71693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71694       };
71695     } catch (...) {
71696       {
71697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71698       };
71699     }
71700   }
71701 }
71702
71703
71704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
71705   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71706   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
71707   Dali::Toolkit::RulerDomain *argp2 ;
71708
71709   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71710   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
71711   if (!argp2) {
71712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
71713     return ;
71714   }
71715   arg2 = *argp2;
71716   {
71717     try {
71718       (arg1)->SetDomain(arg2);
71719     } catch (std::out_of_range& e) {
71720       {
71721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71722       };
71723     } catch (std::exception& e) {
71724       {
71725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71726       };
71727     } catch (...) {
71728       {
71729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71730       };
71731     }
71732   }
71733 }
71734
71735
71736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
71737   void * jresult ;
71738   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71739   Dali::Toolkit::RulerDomain *result = 0 ;
71740
71741   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71742   {
71743     try {
71744       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
71745     } catch (std::out_of_range& e) {
71746       {
71747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71748       };
71749     } catch (std::exception& e) {
71750       {
71751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71752       };
71753     } catch (...) {
71754       {
71755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71756       };
71757     }
71758   }
71759   jresult = (void *)result;
71760   return jresult;
71761 }
71762
71763
71764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
71765   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71766
71767   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71768   {
71769     try {
71770       (arg1)->DisableDomain();
71771     } catch (std::out_of_range& e) {
71772       {
71773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71774       };
71775     } catch (std::exception& e) {
71776       {
71777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71778       };
71779     } catch (...) {
71780       {
71781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71782       };
71783     }
71784   }
71785 }
71786
71787
71788 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71789   float jresult ;
71790   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71791   float arg2 ;
71792   float arg3 ;
71793   float arg4 ;
71794   float result;
71795
71796   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71797   arg2 = (float)jarg2;
71798   arg3 = (float)jarg3;
71799   arg4 = (float)jarg4;
71800   {
71801     try {
71802       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
71803     } catch (std::out_of_range& e) {
71804       {
71805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71806       };
71807     } catch (std::exception& e) {
71808       {
71809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71810       };
71811     } catch (...) {
71812       {
71813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71814       };
71815     }
71816   }
71817   jresult = result;
71818   return jresult;
71819 }
71820
71821
71822 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71823   float jresult ;
71824   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71825   float arg2 ;
71826   float arg3 ;
71827   float result;
71828
71829   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71830   arg2 = (float)jarg2;
71831   arg3 = (float)jarg3;
71832   {
71833     try {
71834       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
71835     } catch (std::out_of_range& e) {
71836       {
71837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71838       };
71839     } catch (std::exception& e) {
71840       {
71841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71842       };
71843     } catch (...) {
71844       {
71845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71846       };
71847     }
71848   }
71849   jresult = result;
71850   return jresult;
71851 }
71852
71853
71854 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
71855   float jresult ;
71856   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71857   float arg2 ;
71858   float result;
71859
71860   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71861   arg2 = (float)jarg2;
71862   {
71863     try {
71864       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
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 (...) {
71874       {
71875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71876       };
71877     }
71878   }
71879   jresult = result;
71880   return jresult;
71881 }
71882
71883
71884 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71885   float jresult ;
71886   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71887   float arg2 ;
71888   float arg3 ;
71889   float arg4 ;
71890   Dali::Toolkit::ClampState *arg5 = 0 ;
71891   float result;
71892
71893   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71894   arg2 = (float)jarg2;
71895   arg3 = (float)jarg3;
71896   arg4 = (float)jarg4;
71897   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71898   if (!arg5) {
71899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71900     return 0;
71901   }
71902   {
71903     try {
71904       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71905     } catch (std::out_of_range& e) {
71906       {
71907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71908       };
71909     } catch (std::exception& e) {
71910       {
71911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71912       };
71913     } catch (...) {
71914       {
71915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71916       };
71917     }
71918   }
71919   jresult = result;
71920   return jresult;
71921 }
71922
71923
71924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
71925   float jresult ;
71926   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71927   float arg2 ;
71928   float arg3 ;
71929   float arg4 ;
71930   float arg5 ;
71931   float result;
71932
71933   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71934   arg2 = (float)jarg2;
71935   arg3 = (float)jarg3;
71936   arg4 = (float)jarg4;
71937   arg5 = (float)jarg5;
71938   {
71939     try {
71940       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
71941     } catch (std::out_of_range& e) {
71942       {
71943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71944       };
71945     } catch (std::exception& e) {
71946       {
71947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71948       };
71949     } catch (...) {
71950       {
71951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71952       };
71953     }
71954   }
71955   jresult = result;
71956   return jresult;
71957 }
71958
71959
71960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
71961   float jresult ;
71962   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71963   float arg2 ;
71964   float arg3 ;
71965   float arg4 ;
71966   float result;
71967
71968   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71969   arg2 = (float)jarg2;
71970   arg3 = (float)jarg3;
71971   arg4 = (float)jarg4;
71972   {
71973     try {
71974       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
71975     } catch (std::out_of_range& e) {
71976       {
71977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71978       };
71979     } catch (std::exception& e) {
71980       {
71981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71982       };
71983     } catch (...) {
71984       {
71985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71986       };
71987     }
71988   }
71989   jresult = result;
71990   return jresult;
71991 }
71992
71993
71994 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
71995   float jresult ;
71996   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71997   float arg2 ;
71998   float arg3 ;
71999   float result;
72000
72001   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72002   arg2 = (float)jarg2;
72003   arg3 = (float)jarg3;
72004   {
72005     try {
72006       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
72007     } catch (std::out_of_range& e) {
72008       {
72009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72010       };
72011     } catch (std::exception& e) {
72012       {
72013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72014       };
72015     } catch (...) {
72016       {
72017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72018       };
72019     }
72020   }
72021   jresult = result;
72022   return jresult;
72023 }
72024
72025
72026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
72027   float jresult ;
72028   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72029   float arg2 ;
72030   float result;
72031
72032   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72033   arg2 = (float)jarg2;
72034   {
72035     try {
72036       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
72037     } catch (std::out_of_range& e) {
72038       {
72039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72040       };
72041     } catch (std::exception& e) {
72042       {
72043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72044       };
72045     } catch (...) {
72046       {
72047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72048       };
72049     }
72050   }
72051   jresult = result;
72052   return jresult;
72053 }
72054
72055
72056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
72057   float jresult ;
72058   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72059   float arg2 ;
72060   float arg3 ;
72061   float arg4 ;
72062   float arg5 ;
72063   Dali::Toolkit::ClampState *arg6 = 0 ;
72064   float result;
72065
72066   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72067   arg2 = (float)jarg2;
72068   arg3 = (float)jarg3;
72069   arg4 = (float)jarg4;
72070   arg5 = (float)jarg5;
72071   arg6 = (Dali::Toolkit::ClampState *)jarg6;
72072   if (!arg6) {
72073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72074     return 0;
72075   }
72076   {
72077     try {
72078       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
72079     } catch (std::out_of_range& e) {
72080       {
72081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72082       };
72083     } catch (std::exception& e) {
72084       {
72085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72086       };
72087     } catch (...) {
72088       {
72089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72090       };
72091     }
72092   }
72093   jresult = result;
72094   return jresult;
72095 }
72096
72097
72098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
72099   void * jresult ;
72100   Dali::Toolkit::DefaultRuler *result = 0 ;
72101
72102   {
72103     try {
72104       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
72105     } catch (std::out_of_range& e) {
72106       {
72107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72108       };
72109     } catch (std::exception& e) {
72110       {
72111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72112       };
72113     } catch (...) {
72114       {
72115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72116       };
72117     }
72118   }
72119   jresult = (void *)result;
72120   return jresult;
72121 }
72122
72123
72124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72125   float jresult ;
72126   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72127   float arg2 ;
72128   float arg3 ;
72129   float result;
72130
72131   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72132   arg2 = (float)jarg2;
72133   arg3 = (float)jarg3;
72134   {
72135     try {
72136       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
72137     } catch (std::out_of_range& e) {
72138       {
72139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72140       };
72141     } catch (std::exception& e) {
72142       {
72143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72144       };
72145     } catch (...) {
72146       {
72147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72148       };
72149     }
72150   }
72151   jresult = result;
72152   return jresult;
72153 }
72154
72155
72156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72157   float jresult ;
72158   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72159   unsigned int arg2 ;
72160   unsigned int *arg3 = 0 ;
72161   bool arg4 ;
72162   float result;
72163
72164   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72165   arg2 = (unsigned int)jarg2;
72166   arg3 = (unsigned int *)jarg3;
72167   arg4 = jarg4 ? true : false;
72168   {
72169     try {
72170       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72171     } catch (std::out_of_range& e) {
72172       {
72173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72174       };
72175     } catch (std::exception& e) {
72176       {
72177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72178       };
72179     } catch (...) {
72180       {
72181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72182       };
72183     }
72184   }
72185   jresult = result;
72186   return jresult;
72187 }
72188
72189
72190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72191   unsigned int jresult ;
72192   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72193   float arg2 ;
72194   bool arg3 ;
72195   unsigned int result;
72196
72197   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72198   arg2 = (float)jarg2;
72199   arg3 = jarg3 ? true : false;
72200   {
72201     try {
72202       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72203     } catch (std::out_of_range& e) {
72204       {
72205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72206       };
72207     } catch (std::exception& e) {
72208       {
72209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72210       };
72211     } catch (...) {
72212       {
72213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72214       };
72215     }
72216   }
72217   jresult = result;
72218   return jresult;
72219 }
72220
72221
72222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
72223   unsigned int jresult ;
72224   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72225   unsigned int result;
72226
72227   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72228   {
72229     try {
72230       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
72231     } catch (std::out_of_range& e) {
72232       {
72233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72234       };
72235     } catch (std::exception& e) {
72236       {
72237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72238       };
72239     } catch (...) {
72240       {
72241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72242       };
72243     }
72244   }
72245   jresult = result;
72246   return jresult;
72247 }
72248
72249
72250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
72251   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72252
72253   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72254   {
72255     try {
72256       delete arg1;
72257     } catch (std::out_of_range& e) {
72258       {
72259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72260       };
72261     } catch (std::exception& e) {
72262       {
72263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72264       };
72265     } catch (...) {
72266       {
72267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72268       };
72269     }
72270   }
72271 }
72272
72273
72274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
72275   void * jresult ;
72276   float arg1 ;
72277   Dali::Toolkit::FixedRuler *result = 0 ;
72278
72279   arg1 = (float)jarg1;
72280   {
72281     try {
72282       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
72283     } catch (std::out_of_range& e) {
72284       {
72285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72286       };
72287     } catch (std::exception& e) {
72288       {
72289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72290       };
72291     } catch (...) {
72292       {
72293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72294       };
72295     }
72296   }
72297   jresult = (void *)result;
72298   return jresult;
72299 }
72300
72301
72302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
72303   void * jresult ;
72304   Dali::Toolkit::FixedRuler *result = 0 ;
72305
72306   {
72307     try {
72308       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
72309     } catch (std::out_of_range& e) {
72310       {
72311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72312       };
72313     } catch (std::exception& e) {
72314       {
72315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72316       };
72317     } catch (...) {
72318       {
72319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72320       };
72321     }
72322   }
72323   jresult = (void *)result;
72324   return jresult;
72325 }
72326
72327
72328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72329   float jresult ;
72330   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72331   float arg2 ;
72332   float arg3 ;
72333   float result;
72334
72335   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72336   arg2 = (float)jarg2;
72337   arg3 = (float)jarg3;
72338   {
72339     try {
72340       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
72341     } catch (std::out_of_range& e) {
72342       {
72343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72344       };
72345     } catch (std::exception& e) {
72346       {
72347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72348       };
72349     } catch (...) {
72350       {
72351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72352       };
72353     }
72354   }
72355   jresult = result;
72356   return jresult;
72357 }
72358
72359
72360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72361   float jresult ;
72362   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72363   unsigned int arg2 ;
72364   unsigned int *arg3 = 0 ;
72365   bool arg4 ;
72366   float result;
72367
72368   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72369   arg2 = (unsigned int)jarg2;
72370   arg3 = (unsigned int *)jarg3;
72371   arg4 = jarg4 ? true : false;
72372   {
72373     try {
72374       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72375     } catch (std::out_of_range& e) {
72376       {
72377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72378       };
72379     } catch (std::exception& e) {
72380       {
72381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72382       };
72383     } catch (...) {
72384       {
72385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72386       };
72387     }
72388   }
72389   jresult = result;
72390   return jresult;
72391 }
72392
72393
72394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72395   unsigned int jresult ;
72396   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72397   float arg2 ;
72398   bool arg3 ;
72399   unsigned int result;
72400
72401   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72402   arg2 = (float)jarg2;
72403   arg3 = jarg3 ? true : false;
72404   {
72405     try {
72406       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72407     } catch (std::out_of_range& e) {
72408       {
72409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72410       };
72411     } catch (std::exception& e) {
72412       {
72413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72414       };
72415     } catch (...) {
72416       {
72417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72418       };
72419     }
72420   }
72421   jresult = result;
72422   return jresult;
72423 }
72424
72425
72426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
72427   unsigned int jresult ;
72428   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72429   unsigned int result;
72430
72431   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72432   {
72433     try {
72434       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
72435     } catch (std::out_of_range& e) {
72436       {
72437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72438       };
72439     } catch (std::exception& e) {
72440       {
72441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72442       };
72443     } catch (...) {
72444       {
72445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72446       };
72447     }
72448   }
72449   jresult = result;
72450   return jresult;
72451 }
72452
72453
72454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
72455   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72456
72457   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72458   {
72459     try {
72460       delete arg1;
72461     } catch (std::out_of_range& e) {
72462       {
72463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72464       };
72465     } catch (std::exception& e) {
72466       {
72467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72468       };
72469     } catch (...) {
72470       {
72471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72472       };
72473     }
72474   }
72475 }
72476
72477
72478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
72479   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72480   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72481
72482   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72483   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72484   if (arg1) (arg1)->scale = *arg2;
72485 }
72486
72487
72488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
72489   void * jresult ;
72490   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72491   Dali::Toolkit::ClampState2D *result = 0 ;
72492
72493   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72494   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
72495   jresult = (void *)result;
72496   return jresult;
72497 }
72498
72499
72500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
72501   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72502   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72503
72504   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72505   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72506   if (arg1) (arg1)->position = *arg2;
72507 }
72508
72509
72510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
72511   void * jresult ;
72512   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72513   Dali::Toolkit::ClampState2D *result = 0 ;
72514
72515   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72516   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
72517   jresult = (void *)result;
72518   return jresult;
72519 }
72520
72521
72522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
72523   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72524   Dali::Toolkit::ClampState arg2 ;
72525
72526   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72527   arg2 = (Dali::Toolkit::ClampState)jarg2;
72528   if (arg1) (arg1)->rotation = arg2;
72529 }
72530
72531
72532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
72533   int jresult ;
72534   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72535   Dali::Toolkit::ClampState result;
72536
72537   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72538   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
72539   jresult = (int)result;
72540   return jresult;
72541 }
72542
72543
72544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
72545   void * jresult ;
72546   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
72547
72548   {
72549     try {
72550       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
72551     } catch (std::out_of_range& e) {
72552       {
72553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72554       };
72555     } catch (std::exception& e) {
72556       {
72557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72558       };
72559     } catch (...) {
72560       {
72561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72562       };
72563     }
72564   }
72565   jresult = (void *)result;
72566   return jresult;
72567 }
72568
72569
72570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
72571   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72572
72573   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72574   {
72575     try {
72576       delete arg1;
72577     } catch (std::out_of_range& e) {
72578       {
72579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72580       };
72581     } catch (std::exception& e) {
72582       {
72583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72584       };
72585     } catch (...) {
72586       {
72587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72588       };
72589     }
72590   }
72591 }
72592
72593
72594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
72595   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72596   Dali::Toolkit::SnapType arg2 ;
72597
72598   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72599   arg2 = (Dali::Toolkit::SnapType)jarg2;
72600   if (arg1) (arg1)->type = arg2;
72601 }
72602
72603
72604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
72605   int jresult ;
72606   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72607   Dali::Toolkit::SnapType result;
72608
72609   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72610   result = (Dali::Toolkit::SnapType) ((arg1)->type);
72611   jresult = (int)result;
72612   return jresult;
72613 }
72614
72615
72616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
72617   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72618   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
72619
72620   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72621   arg2 = (Dali::Vector2 *)jarg2;
72622   if (arg1) (arg1)->position = *arg2;
72623 }
72624
72625
72626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
72627   void * jresult ;
72628   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72629   Dali::Vector2 *result = 0 ;
72630
72631   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72632   result = (Dali::Vector2 *)& ((arg1)->position);
72633   jresult = (void *)result;
72634   return jresult;
72635 }
72636
72637
72638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
72639   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72640   float arg2 ;
72641
72642   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72643   arg2 = (float)jarg2;
72644   if (arg1) (arg1)->duration = arg2;
72645 }
72646
72647
72648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
72649   float jresult ;
72650   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72651   float result;
72652
72653   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72654   result = (float) ((arg1)->duration);
72655   jresult = result;
72656   return jresult;
72657 }
72658
72659
72660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
72661   void * jresult ;
72662   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
72663
72664   {
72665     try {
72666       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
72667     } catch (std::out_of_range& e) {
72668       {
72669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72670       };
72671     } catch (std::exception& e) {
72672       {
72673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72674       };
72675     } catch (...) {
72676       {
72677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72678       };
72679     }
72680   }
72681   jresult = (void *)result;
72682   return jresult;
72683 }
72684
72685
72686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
72687   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72688
72689   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72690   {
72691     try {
72692       delete arg1;
72693     } catch (std::out_of_range& e) {
72694       {
72695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72696       };
72697     } catch (std::exception& e) {
72698       {
72699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72700       };
72701     } catch (...) {
72702       {
72703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72704       };
72705     }
72706   }
72707 }
72708
72709
72710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
72711   int jresult ;
72712   int result;
72713
72714   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
72715   jresult = (int)result;
72716   return jresult;
72717 }
72718
72719
72720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
72721   int jresult ;
72722   int result;
72723
72724   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
72725   jresult = (int)result;
72726   return jresult;
72727 }
72728
72729
72730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
72731   int jresult ;
72732   int result;
72733
72734   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
72735   jresult = (int)result;
72736   return jresult;
72737 }
72738
72739
72740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
72741   int jresult ;
72742   int result;
72743
72744   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
72745   jresult = (int)result;
72746   return jresult;
72747 }
72748
72749
72750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
72751   int jresult ;
72752   int result;
72753
72754   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
72755   jresult = (int)result;
72756   return jresult;
72757 }
72758
72759
72760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
72761   int jresult ;
72762   int result;
72763
72764   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
72765   jresult = (int)result;
72766   return jresult;
72767 }
72768
72769
72770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
72771   int jresult ;
72772   int result;
72773
72774   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
72775   jresult = (int)result;
72776   return jresult;
72777 }
72778
72779
72780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
72781   int jresult ;
72782   int result;
72783
72784   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
72785   jresult = (int)result;
72786   return jresult;
72787 }
72788
72789
72790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
72791   int jresult ;
72792   int result;
72793
72794   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
72795   jresult = (int)result;
72796   return jresult;
72797 }
72798
72799
72800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
72801   int jresult ;
72802   int result;
72803
72804   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
72805   jresult = (int)result;
72806   return jresult;
72807 }
72808
72809
72810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
72811   int jresult ;
72812   int result;
72813
72814   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
72815   jresult = (int)result;
72816   return jresult;
72817 }
72818
72819
72820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
72821   int jresult ;
72822   int result;
72823
72824   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
72825   jresult = (int)result;
72826   return jresult;
72827 }
72828
72829
72830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
72831   int jresult ;
72832   int result;
72833
72834   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
72835   jresult = (int)result;
72836   return jresult;
72837 }
72838
72839
72840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
72841   int jresult ;
72842   int result;
72843
72844   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
72845   jresult = (int)result;
72846   return jresult;
72847 }
72848
72849
72850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
72851   int jresult ;
72852   int result;
72853
72854   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
72855   jresult = (int)result;
72856   return jresult;
72857 }
72858
72859
72860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
72861   int jresult ;
72862   int result;
72863
72864   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
72865   jresult = (int)result;
72866   return jresult;
72867 }
72868
72869
72870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
72871   int jresult ;
72872   int result;
72873
72874   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
72875   jresult = (int)result;
72876   return jresult;
72877 }
72878
72879
72880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
72881   int jresult ;
72882   int result;
72883
72884   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
72885   jresult = (int)result;
72886   return jresult;
72887 }
72888
72889
72890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
72891   int jresult ;
72892   int result;
72893
72894   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
72895   jresult = (int)result;
72896   return jresult;
72897 }
72898
72899
72900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
72901   int jresult ;
72902   int result;
72903
72904   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
72905   jresult = (int)result;
72906   return jresult;
72907 }
72908
72909
72910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
72911   int jresult ;
72912   int result;
72913
72914   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
72915   jresult = (int)result;
72916   return jresult;
72917 }
72918
72919
72920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
72921   int jresult ;
72922   int result;
72923
72924   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
72925   jresult = (int)result;
72926   return jresult;
72927 }
72928
72929
72930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
72931   int jresult ;
72932   int result;
72933
72934   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
72935   jresult = (int)result;
72936   return jresult;
72937 }
72938
72939
72940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
72941   int jresult ;
72942   int result;
72943
72944   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
72945   jresult = (int)result;
72946   return jresult;
72947 }
72948
72949
72950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
72951   int jresult ;
72952   int result;
72953
72954   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
72955   jresult = (int)result;
72956   return jresult;
72957 }
72958
72959
72960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
72961   void * jresult ;
72962   Dali::Toolkit::ScrollView::Property *result = 0 ;
72963
72964   {
72965     try {
72966       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
72967     } catch (std::out_of_range& e) {
72968       {
72969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72970       };
72971     } catch (std::exception& e) {
72972       {
72973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72974       };
72975     } catch (...) {
72976       {
72977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72978       };
72979     }
72980   }
72981   jresult = (void *)result;
72982   return jresult;
72983 }
72984
72985
72986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
72987   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
72988
72989   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
72990   {
72991     try {
72992       delete arg1;
72993     } catch (std::out_of_range& e) {
72994       {
72995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72996       };
72997     } catch (std::exception& e) {
72998       {
72999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73000       };
73001     } catch (...) {
73002       {
73003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73004       };
73005     }
73006   }
73007 }
73008
73009
73010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
73011   void * jresult ;
73012   Dali::Toolkit::ScrollView *result = 0 ;
73013
73014   {
73015     try {
73016       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
73017     } catch (std::out_of_range& e) {
73018       {
73019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73020       };
73021     } catch (std::exception& e) {
73022       {
73023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73024       };
73025     } catch (...) {
73026       {
73027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73028       };
73029     }
73030   }
73031   jresult = (void *)result;
73032   return jresult;
73033 }
73034
73035
73036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
73037   void * jresult ;
73038   Dali::Toolkit::ScrollView *arg1 = 0 ;
73039   Dali::Toolkit::ScrollView *result = 0 ;
73040
73041   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73042   if (!arg1) {
73043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73044     return 0;
73045   }
73046   {
73047     try {
73048       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
73049     } catch (std::out_of_range& e) {
73050       {
73051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73052       };
73053     } catch (std::exception& e) {
73054       {
73055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73056       };
73057     } catch (...) {
73058       {
73059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73060       };
73061     }
73062   }
73063   jresult = (void *)result;
73064   return jresult;
73065 }
73066
73067
73068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
73069   void * jresult ;
73070   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73071   Dali::Toolkit::ScrollView *arg2 = 0 ;
73072   Dali::Toolkit::ScrollView *result = 0 ;
73073
73074   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73075   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
73076   if (!arg2) {
73077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73078     return 0;
73079   }
73080   {
73081     try {
73082       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
73083     } catch (std::out_of_range& e) {
73084       {
73085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73086       };
73087     } catch (std::exception& e) {
73088       {
73089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73090       };
73091     } catch (...) {
73092       {
73093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73094       };
73095     }
73096   }
73097   jresult = (void *)result;
73098   return jresult;
73099 }
73100
73101
73102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
73103   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73104
73105   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73106   {
73107     try {
73108       delete arg1;
73109     } catch (std::out_of_range& e) {
73110       {
73111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73112       };
73113     } catch (std::exception& e) {
73114       {
73115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73116       };
73117     } catch (...) {
73118       {
73119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73120       };
73121     }
73122   }
73123 }
73124
73125
73126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
73127   void * jresult ;
73128   Dali::Toolkit::ScrollView result;
73129
73130   {
73131     try {
73132       result = Dali::Toolkit::ScrollView::New();
73133     } catch (std::out_of_range& e) {
73134       {
73135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73136       };
73137     } catch (std::exception& e) {
73138       {
73139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73140       };
73141     } catch (...) {
73142       {
73143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73144       };
73145     }
73146   }
73147   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73148   return jresult;
73149 }
73150
73151
73152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
73153   void * jresult ;
73154   Dali::BaseHandle arg1 ;
73155   Dali::BaseHandle *argp1 ;
73156   Dali::Toolkit::ScrollView result;
73157
73158   argp1 = (Dali::BaseHandle *)jarg1;
73159   if (!argp1) {
73160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73161     return 0;
73162   }
73163   arg1 = *argp1;
73164   {
73165     try {
73166       result = Dali::Toolkit::ScrollView::DownCast(arg1);
73167     } catch (std::out_of_range& e) {
73168       {
73169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73170       };
73171     } catch (std::exception& e) {
73172       {
73173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73174       };
73175     } catch (...) {
73176       {
73177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73178       };
73179     }
73180   }
73181   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73182   return jresult;
73183 }
73184
73185
73186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
73187   void * jresult ;
73188   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73189   Dali::AlphaFunction result;
73190
73191   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73192   {
73193     try {
73194       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
73195     } catch (std::out_of_range& e) {
73196       {
73197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73198       };
73199     } catch (std::exception& e) {
73200       {
73201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73202       };
73203     } catch (...) {
73204       {
73205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73206       };
73207     }
73208   }
73209   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73210   return jresult;
73211 }
73212
73213
73214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
73215   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73216   Dali::AlphaFunction arg2 ;
73217   Dali::AlphaFunction *argp2 ;
73218
73219   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73220   argp2 = (Dali::AlphaFunction *)jarg2;
73221   if (!argp2) {
73222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73223     return ;
73224   }
73225   arg2 = *argp2;
73226   {
73227     try {
73228       (arg1)->SetScrollSnapAlphaFunction(arg2);
73229     } catch (std::out_of_range& e) {
73230       {
73231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73232       };
73233     } catch (std::exception& e) {
73234       {
73235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73236       };
73237     } catch (...) {
73238       {
73239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73240       };
73241     }
73242   }
73243 }
73244
73245
73246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
73247   void * jresult ;
73248   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73249   Dali::AlphaFunction result;
73250
73251   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73252   {
73253     try {
73254       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
73255     } catch (std::out_of_range& e) {
73256       {
73257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73258       };
73259     } catch (std::exception& e) {
73260       {
73261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73262       };
73263     } catch (...) {
73264       {
73265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73266       };
73267     }
73268   }
73269   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73270   return jresult;
73271 }
73272
73273
73274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
73275   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73276   Dali::AlphaFunction arg2 ;
73277   Dali::AlphaFunction *argp2 ;
73278
73279   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73280   argp2 = (Dali::AlphaFunction *)jarg2;
73281   if (!argp2) {
73282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73283     return ;
73284   }
73285   arg2 = *argp2;
73286   {
73287     try {
73288       (arg1)->SetScrollFlickAlphaFunction(arg2);
73289     } catch (std::out_of_range& e) {
73290       {
73291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73292       };
73293     } catch (std::exception& e) {
73294       {
73295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73296       };
73297     } catch (...) {
73298       {
73299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73300       };
73301     }
73302   }
73303 }
73304
73305
73306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
73307   float jresult ;
73308   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73309   float result;
73310
73311   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73312   {
73313     try {
73314       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
73315     } catch (std::out_of_range& e) {
73316       {
73317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73318       };
73319     } catch (std::exception& e) {
73320       {
73321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73322       };
73323     } catch (...) {
73324       {
73325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73326       };
73327     }
73328   }
73329   jresult = result;
73330   return jresult;
73331 }
73332
73333
73334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
73335   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73336   float arg2 ;
73337
73338   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73339   arg2 = (float)jarg2;
73340   {
73341     try {
73342       (arg1)->SetScrollSnapDuration(arg2);
73343     } catch (std::out_of_range& e) {
73344       {
73345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73346       };
73347     } catch (std::exception& e) {
73348       {
73349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73350       };
73351     } catch (...) {
73352       {
73353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73354       };
73355     }
73356   }
73357 }
73358
73359
73360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
73361   float jresult ;
73362   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73363   float result;
73364
73365   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73366   {
73367     try {
73368       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
73369     } catch (std::out_of_range& e) {
73370       {
73371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73372       };
73373     } catch (std::exception& e) {
73374       {
73375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73376       };
73377     } catch (...) {
73378       {
73379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73380       };
73381     }
73382   }
73383   jresult = result;
73384   return jresult;
73385 }
73386
73387
73388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
73389   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73390   float arg2 ;
73391
73392   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73393   arg2 = (float)jarg2;
73394   {
73395     try {
73396       (arg1)->SetScrollFlickDuration(arg2);
73397     } catch (std::out_of_range& e) {
73398       {
73399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73400       };
73401     } catch (std::exception& e) {
73402       {
73403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73404       };
73405     } catch (...) {
73406       {
73407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73408       };
73409     }
73410   }
73411 }
73412
73413
73414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
73415   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73416   Dali::Toolkit::RulerPtr arg2 ;
73417   Dali::Toolkit::RulerPtr *argp2 ;
73418
73419   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73420   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73421   if (!argp2) {
73422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73423     return ;
73424   }
73425   arg2 = *argp2;
73426   {
73427     try {
73428       (arg1)->SetRulerX(arg2);
73429     } catch (std::out_of_range& e) {
73430       {
73431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73432       };
73433     } catch (std::exception& e) {
73434       {
73435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73436       };
73437     } catch (...) {
73438       {
73439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73440       };
73441     }
73442   }
73443 }
73444
73445
73446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
73447   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73448   Dali::Toolkit::RulerPtr arg2 ;
73449   Dali::Toolkit::RulerPtr *argp2 ;
73450
73451   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73452   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73453   if (!argp2) {
73454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73455     return ;
73456   }
73457   arg2 = *argp2;
73458   {
73459     try {
73460       (arg1)->SetRulerY(arg2);
73461     } catch (std::out_of_range& e) {
73462       {
73463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73464       };
73465     } catch (std::exception& e) {
73466       {
73467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73468       };
73469     } catch (...) {
73470       {
73471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73472       };
73473     }
73474   }
73475 }
73476
73477
73478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
73479   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73480   bool arg2 ;
73481
73482   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73483   arg2 = jarg2 ? true : false;
73484   {
73485     try {
73486       (arg1)->SetScrollSensitive(arg2);
73487     } catch (std::out_of_range& e) {
73488       {
73489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73490       };
73491     } catch (std::exception& e) {
73492       {
73493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73494       };
73495     } catch (...) {
73496       {
73497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73498       };
73499     }
73500   }
73501 }
73502
73503
73504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
73505   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73506   float arg2 ;
73507   float arg3 ;
73508
73509   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73510   arg2 = (float)jarg2;
73511   arg3 = (float)jarg3;
73512   {
73513     try {
73514       (arg1)->SetMaxOvershoot(arg2,arg3);
73515     } catch (std::out_of_range& e) {
73516       {
73517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73518       };
73519     } catch (std::exception& e) {
73520       {
73521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73522       };
73523     } catch (...) {
73524       {
73525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73526       };
73527     }
73528   }
73529 }
73530
73531
73532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
73533   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73534   Dali::AlphaFunction arg2 ;
73535   Dali::AlphaFunction *argp2 ;
73536
73537   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73538   argp2 = (Dali::AlphaFunction *)jarg2;
73539   if (!argp2) {
73540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73541     return ;
73542   }
73543   arg2 = *argp2;
73544   {
73545     try {
73546       (arg1)->SetSnapOvershootAlphaFunction(arg2);
73547     } catch (std::out_of_range& e) {
73548       {
73549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73550       };
73551     } catch (std::exception& e) {
73552       {
73553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73554       };
73555     } catch (...) {
73556       {
73557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73558       };
73559     }
73560   }
73561 }
73562
73563
73564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
73565   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73566   float arg2 ;
73567
73568   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73569   arg2 = (float)jarg2;
73570   {
73571     try {
73572       (arg1)->SetSnapOvershootDuration(arg2);
73573     } catch (std::out_of_range& e) {
73574       {
73575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73576       };
73577     } catch (std::exception& e) {
73578       {
73579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73580       };
73581     } catch (...) {
73582       {
73583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73584       };
73585     }
73586   }
73587 }
73588
73589
73590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
73591   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73592   bool arg2 ;
73593
73594   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73595   arg2 = jarg2 ? true : false;
73596   {
73597     try {
73598       (arg1)->SetActorAutoSnap(arg2);
73599     } catch (std::out_of_range& e) {
73600       {
73601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73602       };
73603     } catch (std::exception& e) {
73604       {
73605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73606       };
73607     } catch (...) {
73608       {
73609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73610       };
73611     }
73612   }
73613 }
73614
73615
73616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
73617   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73618   bool arg2 ;
73619
73620   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73621   arg2 = jarg2 ? true : false;
73622   {
73623     try {
73624       (arg1)->SetWrapMode(arg2);
73625     } catch (std::out_of_range& e) {
73626       {
73627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73628       };
73629     } catch (std::exception& e) {
73630       {
73631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73632       };
73633     } catch (...) {
73634       {
73635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73636       };
73637     }
73638   }
73639 }
73640
73641
73642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
73643   int jresult ;
73644   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73645   int result;
73646
73647   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73648   {
73649     try {
73650       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
73651     } catch (std::out_of_range& e) {
73652       {
73653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73654       };
73655     } catch (std::exception& e) {
73656       {
73657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73658       };
73659     } catch (...) {
73660       {
73661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73662       };
73663     }
73664   }
73665   jresult = result;
73666   return jresult;
73667 }
73668
73669
73670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
73671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73672   int arg2 ;
73673
73674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73675   arg2 = (int)jarg2;
73676   {
73677     try {
73678       (arg1)->SetScrollUpdateDistance(arg2);
73679     } catch (std::out_of_range& e) {
73680       {
73681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73682       };
73683     } catch (std::exception& e) {
73684       {
73685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73686       };
73687     } catch (...) {
73688       {
73689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73690       };
73691     }
73692   }
73693 }
73694
73695
73696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
73697   unsigned int jresult ;
73698   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73699   bool result;
73700
73701   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73702   {
73703     try {
73704       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
73705     } catch (std::out_of_range& e) {
73706       {
73707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73708       };
73709     } catch (std::exception& e) {
73710       {
73711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73712       };
73713     } catch (...) {
73714       {
73715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73716       };
73717     }
73718   }
73719   jresult = result;
73720   return jresult;
73721 }
73722
73723
73724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
73725   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73726   bool arg2 ;
73727
73728   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73729   arg2 = jarg2 ? true : false;
73730   {
73731     try {
73732       (arg1)->SetAxisAutoLock(arg2);
73733     } catch (std::out_of_range& e) {
73734       {
73735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73736       };
73737     } catch (std::exception& e) {
73738       {
73739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73740       };
73741     } catch (...) {
73742       {
73743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73744       };
73745     }
73746   }
73747 }
73748
73749
73750 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
73751   float jresult ;
73752   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73753   float result;
73754
73755   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73756   {
73757     try {
73758       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
73759     } catch (std::out_of_range& e) {
73760       {
73761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73762       };
73763     } catch (std::exception& e) {
73764       {
73765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73766       };
73767     } catch (...) {
73768       {
73769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73770       };
73771     }
73772   }
73773   jresult = result;
73774   return jresult;
73775 }
73776
73777
73778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
73779   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73780   float arg2 ;
73781
73782   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73783   arg2 = (float)jarg2;
73784   {
73785     try {
73786       (arg1)->SetAxisAutoLockGradient(arg2);
73787     } catch (std::out_of_range& e) {
73788       {
73789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73790       };
73791     } catch (std::exception& e) {
73792       {
73793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73794       };
73795     } catch (...) {
73796       {
73797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73798       };
73799     }
73800   }
73801 }
73802
73803
73804 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
73805   float jresult ;
73806   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73807   float result;
73808
73809   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73810   {
73811     try {
73812       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
73813     } catch (std::out_of_range& e) {
73814       {
73815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73816       };
73817     } catch (std::exception& e) {
73818       {
73819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73820       };
73821     } catch (...) {
73822       {
73823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73824       };
73825     }
73826   }
73827   jresult = result;
73828   return jresult;
73829 }
73830
73831
73832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
73833   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73834   float arg2 ;
73835
73836   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73837   arg2 = (float)jarg2;
73838   {
73839     try {
73840       (arg1)->SetFrictionCoefficient(arg2);
73841     } catch (std::out_of_range& e) {
73842       {
73843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73844       };
73845     } catch (std::exception& e) {
73846       {
73847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73848       };
73849     } catch (...) {
73850       {
73851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73852       };
73853     }
73854   }
73855 }
73856
73857
73858 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
73859   float jresult ;
73860   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73861   float result;
73862
73863   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73864   {
73865     try {
73866       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
73867     } catch (std::out_of_range& e) {
73868       {
73869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73870       };
73871     } catch (std::exception& e) {
73872       {
73873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73874       };
73875     } catch (...) {
73876       {
73877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73878       };
73879     }
73880   }
73881   jresult = result;
73882   return jresult;
73883 }
73884
73885
73886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
73887   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73888   float arg2 ;
73889
73890   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73891   arg2 = (float)jarg2;
73892   {
73893     try {
73894       (arg1)->SetFlickSpeedCoefficient(arg2);
73895     } catch (std::out_of_range& e) {
73896       {
73897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73898       };
73899     } catch (std::exception& e) {
73900       {
73901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73902       };
73903     } catch (...) {
73904       {
73905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73906       };
73907     }
73908   }
73909 }
73910
73911
73912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
73913   void * jresult ;
73914   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73915   Dali::Vector2 result;
73916
73917   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73918   {
73919     try {
73920       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
73921     } catch (std::out_of_range& e) {
73922       {
73923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73924       };
73925     } catch (std::exception& e) {
73926       {
73927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73928       };
73929     } catch (...) {
73930       {
73931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73932       };
73933     }
73934   }
73935   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
73936   return jresult;
73937 }
73938
73939
73940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
73941   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73942   Dali::Vector2 *arg2 = 0 ;
73943
73944   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73945   arg2 = (Dali::Vector2 *)jarg2;
73946   if (!arg2) {
73947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
73948     return ;
73949   }
73950   {
73951     try {
73952       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
73953     } catch (std::out_of_range& e) {
73954       {
73955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73956       };
73957     } catch (std::exception& e) {
73958       {
73959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73960       };
73961     } catch (...) {
73962       {
73963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73964       };
73965     }
73966   }
73967 }
73968
73969
73970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
73971   float jresult ;
73972   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73973   float result;
73974
73975   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73976   {
73977     try {
73978       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
73979     } catch (std::out_of_range& e) {
73980       {
73981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73982       };
73983     } catch (std::exception& e) {
73984       {
73985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73986       };
73987     } catch (...) {
73988       {
73989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73990       };
73991     }
73992   }
73993   jresult = result;
73994   return jresult;
73995 }
73996
73997
73998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
73999   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74000   float arg2 ;
74001
74002   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74003   arg2 = (float)jarg2;
74004   {
74005     try {
74006       (arg1)->SetMinimumSpeedForFlick(arg2);
74007     } catch (std::out_of_range& e) {
74008       {
74009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74010       };
74011     } catch (std::exception& e) {
74012       {
74013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74014       };
74015     } catch (...) {
74016       {
74017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74018       };
74019     }
74020   }
74021 }
74022
74023
74024 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
74025   float jresult ;
74026   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74027   float result;
74028
74029   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74030   {
74031     try {
74032       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
74033     } catch (std::out_of_range& e) {
74034       {
74035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74036       };
74037     } catch (std::exception& e) {
74038       {
74039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74040       };
74041     } catch (...) {
74042       {
74043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74044       };
74045     }
74046   }
74047   jresult = result;
74048   return jresult;
74049 }
74050
74051
74052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
74053   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74054   float arg2 ;
74055
74056   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74057   arg2 = (float)jarg2;
74058   {
74059     try {
74060       (arg1)->SetMaxFlickSpeed(arg2);
74061     } catch (std::out_of_range& e) {
74062       {
74063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74064       };
74065     } catch (std::exception& e) {
74066       {
74067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74068       };
74069     } catch (...) {
74070       {
74071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74072       };
74073     }
74074   }
74075 }
74076
74077
74078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
74079   void * jresult ;
74080   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74081   Dali::Vector2 result;
74082
74083   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74084   {
74085     try {
74086       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
74087     } catch (std::out_of_range& e) {
74088       {
74089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74090       };
74091     } catch (std::exception& e) {
74092       {
74093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74094       };
74095     } catch (...) {
74096       {
74097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74098       };
74099     }
74100   }
74101   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74102   return jresult;
74103 }
74104
74105
74106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
74107   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74108   Dali::Vector2 arg2 ;
74109   Dali::Vector2 *argp2 ;
74110
74111   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74112   argp2 = (Dali::Vector2 *)jarg2;
74113   if (!argp2) {
74114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
74115     return ;
74116   }
74117   arg2 = *argp2;
74118   {
74119     try {
74120       (arg1)->SetWheelScrollDistanceStep(arg2);
74121     } catch (std::out_of_range& e) {
74122       {
74123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74124       };
74125     } catch (std::exception& e) {
74126       {
74127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74128       };
74129     } catch (...) {
74130       {
74131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74132       };
74133     }
74134   }
74135 }
74136
74137
74138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
74139   void * jresult ;
74140   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74141   Dali::Vector2 result;
74142
74143   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74144   {
74145     try {
74146       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
74147     } catch (std::out_of_range& e) {
74148       {
74149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74150       };
74151     } catch (std::exception& e) {
74152       {
74153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74154       };
74155     } catch (...) {
74156       {
74157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74158       };
74159     }
74160   }
74161   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74162   return jresult;
74163 }
74164
74165
74166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
74167   unsigned int jresult ;
74168   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74169   unsigned int result;
74170
74171   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74172   {
74173     try {
74174       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
74175     } catch (std::out_of_range& e) {
74176       {
74177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74178       };
74179     } catch (std::exception& e) {
74180       {
74181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74182       };
74183     } catch (...) {
74184       {
74185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74186       };
74187     }
74188   }
74189   jresult = result;
74190   return jresult;
74191 }
74192
74193
74194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
74195   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74196   Dali::Vector2 *arg2 = 0 ;
74197
74198   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74199   arg2 = (Dali::Vector2 *)jarg2;
74200   if (!arg2) {
74201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74202     return ;
74203   }
74204   {
74205     try {
74206       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
74207     } catch (std::out_of_range& e) {
74208       {
74209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74210       };
74211     } catch (std::exception& e) {
74212       {
74213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74214       };
74215     } catch (...) {
74216       {
74217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74218       };
74219     }
74220   }
74221 }
74222
74223
74224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
74225   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74226   Dali::Vector2 *arg2 = 0 ;
74227   float arg3 ;
74228
74229   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74230   arg2 = (Dali::Vector2 *)jarg2;
74231   if (!arg2) {
74232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74233     return ;
74234   }
74235   arg3 = (float)jarg3;
74236   {
74237     try {
74238       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
74239     } catch (std::out_of_range& e) {
74240       {
74241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74242       };
74243     } catch (std::exception& e) {
74244       {
74245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74246       };
74247     } catch (...) {
74248       {
74249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74250       };
74251     }
74252   }
74253 }
74254
74255
74256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
74257   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74258   Dali::Vector2 *arg2 = 0 ;
74259   float arg3 ;
74260   Dali::AlphaFunction arg4 ;
74261   Dali::AlphaFunction *argp4 ;
74262
74263   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74264   arg2 = (Dali::Vector2 *)jarg2;
74265   if (!arg2) {
74266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74267     return ;
74268   }
74269   arg3 = (float)jarg3;
74270   argp4 = (Dali::AlphaFunction *)jarg4;
74271   if (!argp4) {
74272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74273     return ;
74274   }
74275   arg4 = *argp4;
74276   {
74277     try {
74278       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
74279     } catch (std::out_of_range& e) {
74280       {
74281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74282       };
74283     } catch (std::exception& e) {
74284       {
74285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74286       };
74287     } catch (...) {
74288       {
74289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74290       };
74291     }
74292   }
74293 }
74294
74295
74296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
74297   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74298   Dali::Vector2 *arg2 = 0 ;
74299   float arg3 ;
74300   Dali::Toolkit::DirectionBias arg4 ;
74301   Dali::Toolkit::DirectionBias arg5 ;
74302
74303   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74304   arg2 = (Dali::Vector2 *)jarg2;
74305   if (!arg2) {
74306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74307     return ;
74308   }
74309   arg3 = (float)jarg3;
74310   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74311   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74312   {
74313     try {
74314       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
74315     } catch (std::out_of_range& e) {
74316       {
74317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74318       };
74319     } catch (std::exception& e) {
74320       {
74321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74322       };
74323     } catch (...) {
74324       {
74325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74326       };
74327     }
74328   }
74329 }
74330
74331
74332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
74333   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74334   Dali::Vector2 *arg2 = 0 ;
74335   float arg3 ;
74336   Dali::AlphaFunction arg4 ;
74337   Dali::Toolkit::DirectionBias arg5 ;
74338   Dali::Toolkit::DirectionBias arg6 ;
74339   Dali::AlphaFunction *argp4 ;
74340
74341   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74342   arg2 = (Dali::Vector2 *)jarg2;
74343   if (!arg2) {
74344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74345     return ;
74346   }
74347   arg3 = (float)jarg3;
74348   argp4 = (Dali::AlphaFunction *)jarg4;
74349   if (!argp4) {
74350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74351     return ;
74352   }
74353   arg4 = *argp4;
74354   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74355   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
74356   {
74357     try {
74358       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
74359     } catch (std::out_of_range& e) {
74360       {
74361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74362       };
74363     } catch (std::exception& e) {
74364       {
74365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74366       };
74367     } catch (...) {
74368       {
74369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74370       };
74371     }
74372   }
74373 }
74374
74375
74376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
74377   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74378   unsigned int arg2 ;
74379
74380   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74381   arg2 = (unsigned int)jarg2;
74382   {
74383     try {
74384       (arg1)->ScrollTo(arg2);
74385     } catch (std::out_of_range& e) {
74386       {
74387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74388       };
74389     } catch (std::exception& e) {
74390       {
74391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74392       };
74393     } catch (...) {
74394       {
74395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74396       };
74397     }
74398   }
74399 }
74400
74401
74402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
74403   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74404   unsigned int arg2 ;
74405   float arg3 ;
74406
74407   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74408   arg2 = (unsigned int)jarg2;
74409   arg3 = (float)jarg3;
74410   {
74411     try {
74412       (arg1)->ScrollTo(arg2,arg3);
74413     } catch (std::out_of_range& e) {
74414       {
74415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74416       };
74417     } catch (std::exception& e) {
74418       {
74419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74420       };
74421     } catch (...) {
74422       {
74423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74424       };
74425     }
74426   }
74427 }
74428
74429
74430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
74431   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74432   unsigned int arg2 ;
74433   float arg3 ;
74434   Dali::Toolkit::DirectionBias arg4 ;
74435
74436   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74437   arg2 = (unsigned int)jarg2;
74438   arg3 = (float)jarg3;
74439   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74440   {
74441     try {
74442       (arg1)->ScrollTo(arg2,arg3,arg4);
74443     } catch (std::out_of_range& e) {
74444       {
74445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74446       };
74447     } catch (std::exception& e) {
74448       {
74449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74450       };
74451     } catch (...) {
74452       {
74453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74454       };
74455     }
74456   }
74457 }
74458
74459
74460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
74461   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74462   Dali::Actor *arg2 = 0 ;
74463
74464   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74465   arg2 = (Dali::Actor *)jarg2;
74466   if (!arg2) {
74467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74468     return ;
74469   }
74470   {
74471     try {
74472       (arg1)->ScrollTo(*arg2);
74473     } catch (std::out_of_range& e) {
74474       {
74475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74476       };
74477     } catch (std::exception& e) {
74478       {
74479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74480       };
74481     } catch (...) {
74482       {
74483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74484       };
74485     }
74486   }
74487 }
74488
74489
74490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
74491   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74492   Dali::Actor *arg2 = 0 ;
74493   float arg3 ;
74494
74495   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74496   arg2 = (Dali::Actor *)jarg2;
74497   if (!arg2) {
74498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74499     return ;
74500   }
74501   arg3 = (float)jarg3;
74502   {
74503     try {
74504       (arg1)->ScrollTo(*arg2,arg3);
74505     } catch (std::out_of_range& e) {
74506       {
74507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74508       };
74509     } catch (std::exception& e) {
74510       {
74511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74512       };
74513     } catch (...) {
74514       {
74515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74516       };
74517     }
74518   }
74519 }
74520
74521
74522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
74523   unsigned int jresult ;
74524   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74525   bool result;
74526
74527   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74528   {
74529     try {
74530       result = (bool)(arg1)->ScrollToSnapPoint();
74531     } catch (std::out_of_range& e) {
74532       {
74533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74534       };
74535     } catch (std::exception& e) {
74536       {
74537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74538       };
74539     } catch (...) {
74540       {
74541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74542       };
74543     }
74544   }
74545   jresult = result;
74546   return jresult;
74547 }
74548
74549
74550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
74551   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74552   Dali::Constraint arg2 ;
74553   Dali::Constraint *argp2 ;
74554
74555   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74556   argp2 = (Dali::Constraint *)jarg2;
74557   if (!argp2) {
74558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
74559     return ;
74560   }
74561   arg2 = *argp2;
74562   {
74563     try {
74564       (arg1)->ApplyConstraintToChildren(arg2);
74565     } catch (std::out_of_range& e) {
74566       {
74567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74568       };
74569     } catch (std::exception& e) {
74570       {
74571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74572       };
74573     } catch (...) {
74574       {
74575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74576       };
74577     }
74578   }
74579 }
74580
74581
74582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
74583   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74584
74585   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74586   {
74587     try {
74588       (arg1)->RemoveConstraintsFromChildren();
74589     } catch (std::out_of_range& e) {
74590       {
74591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74592       };
74593     } catch (std::exception& e) {
74594       {
74595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74596       };
74597     } catch (...) {
74598       {
74599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74600       };
74601     }
74602   }
74603 }
74604
74605
74606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
74607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74608   Dali::Toolkit::ScrollViewEffect arg2 ;
74609   Dali::Toolkit::ScrollViewEffect *argp2 ;
74610
74611   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74612   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74613   if (!argp2) {
74614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74615     return ;
74616   }
74617   arg2 = *argp2;
74618   {
74619     try {
74620       (arg1)->ApplyEffect(arg2);
74621     } catch (std::out_of_range& e) {
74622       {
74623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74624       };
74625     } catch (std::exception& e) {
74626       {
74627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74628       };
74629     } catch (...) {
74630       {
74631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74632       };
74633     }
74634   }
74635 }
74636
74637
74638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
74639   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74640   Dali::Toolkit::ScrollViewEffect arg2 ;
74641   Dali::Toolkit::ScrollViewEffect *argp2 ;
74642
74643   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74644   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74645   if (!argp2) {
74646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74647     return ;
74648   }
74649   arg2 = *argp2;
74650   {
74651     try {
74652       (arg1)->RemoveEffect(arg2);
74653     } catch (std::out_of_range& e) {
74654       {
74655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74656       };
74657     } catch (std::exception& e) {
74658       {
74659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74660       };
74661     } catch (...) {
74662       {
74663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74664       };
74665     }
74666   }
74667 }
74668
74669
74670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
74671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74672
74673   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74674   {
74675     try {
74676       (arg1)->RemoveAllEffects();
74677     } catch (std::out_of_range& e) {
74678       {
74679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74680       };
74681     } catch (std::exception& e) {
74682       {
74683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74684       };
74685     } catch (...) {
74686       {
74687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74688       };
74689     }
74690   }
74691 }
74692
74693
74694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
74695   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74696   Dali::Actor arg2 ;
74697   Dali::Actor *argp2 ;
74698
74699   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74700   argp2 = (Dali::Actor *)jarg2;
74701   if (!argp2) {
74702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74703     return ;
74704   }
74705   arg2 = *argp2;
74706   {
74707     try {
74708       (arg1)->BindActor(arg2);
74709     } catch (std::out_of_range& e) {
74710       {
74711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74712       };
74713     } catch (std::exception& e) {
74714       {
74715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74716       };
74717     } catch (...) {
74718       {
74719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74720       };
74721     }
74722   }
74723 }
74724
74725
74726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
74727   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74728   Dali::Actor arg2 ;
74729   Dali::Actor *argp2 ;
74730
74731   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74732   argp2 = (Dali::Actor *)jarg2;
74733   if (!argp2) {
74734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74735     return ;
74736   }
74737   arg2 = *argp2;
74738   {
74739     try {
74740       (arg1)->UnbindActor(arg2);
74741     } catch (std::out_of_range& e) {
74742       {
74743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74744       };
74745     } catch (std::exception& e) {
74746       {
74747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74748       };
74749     } catch (...) {
74750       {
74751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74752       };
74753     }
74754   }
74755 }
74756
74757
74758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
74759   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74760   Dali::Radian arg2 ;
74761   Dali::Radian arg3 ;
74762   Dali::Radian *argp2 ;
74763   Dali::Radian *argp3 ;
74764
74765   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74766   argp2 = (Dali::Radian *)jarg2;
74767   if (!argp2) {
74768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74769     return ;
74770   }
74771   arg2 = *argp2;
74772   argp3 = (Dali::Radian *)jarg3;
74773   if (!argp3) {
74774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74775     return ;
74776   }
74777   arg3 = *argp3;
74778   {
74779     try {
74780       (arg1)->SetScrollingDirection(arg2,arg3);
74781     } catch (std::out_of_range& e) {
74782       {
74783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74784       };
74785     } catch (std::exception& e) {
74786       {
74787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74788       };
74789     } catch (...) {
74790       {
74791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74792       };
74793     }
74794   }
74795 }
74796
74797
74798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
74799   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74800   Dali::Radian arg2 ;
74801   Dali::Radian *argp2 ;
74802
74803   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74804   argp2 = (Dali::Radian *)jarg2;
74805   if (!argp2) {
74806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74807     return ;
74808   }
74809   arg2 = *argp2;
74810   {
74811     try {
74812       (arg1)->SetScrollingDirection(arg2);
74813     } catch (std::out_of_range& e) {
74814       {
74815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74816       };
74817     } catch (std::exception& e) {
74818       {
74819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74820       };
74821     } catch (...) {
74822       {
74823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74824       };
74825     }
74826   }
74827 }
74828
74829
74830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
74831   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74832   Dali::Radian arg2 ;
74833   Dali::Radian *argp2 ;
74834
74835   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74836   argp2 = (Dali::Radian *)jarg2;
74837   if (!argp2) {
74838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
74839     return ;
74840   }
74841   arg2 = *argp2;
74842   {
74843     try {
74844       (arg1)->RemoveScrollingDirection(arg2);
74845     } catch (std::out_of_range& e) {
74846       {
74847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74848       };
74849     } catch (std::exception& e) {
74850       {
74851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74852       };
74853     } catch (...) {
74854       {
74855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74856       };
74857     }
74858   }
74859 }
74860
74861
74862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
74863   void * jresult ;
74864   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74865   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
74866
74867   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74868   {
74869     try {
74870       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
74871     } catch (std::out_of_range& e) {
74872       {
74873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74874       };
74875     } catch (std::exception& e) {
74876       {
74877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74878       };
74879     } catch (...) {
74880       {
74881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74882       };
74883     }
74884   }
74885   jresult = (void *)result;
74886   return jresult;
74887 }
74888
74889
74890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
74891   int jresult ;
74892   int result;
74893
74894   result = (int)Dali::Toolkit::TableView::Property::ROWS;
74895   jresult = (int)result;
74896   return jresult;
74897 }
74898
74899
74900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
74901   int jresult ;
74902   int result;
74903
74904   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
74905   jresult = (int)result;
74906   return jresult;
74907 }
74908
74909
74910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
74911   int jresult ;
74912   int result;
74913
74914   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
74915   jresult = (int)result;
74916   return jresult;
74917 }
74918
74919
74920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
74921   int jresult ;
74922   int result;
74923
74924   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
74925   jresult = (int)result;
74926   return jresult;
74927 }
74928
74929
74930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
74931   int jresult ;
74932   int result;
74933
74934   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
74935   jresult = (int)result;
74936   return jresult;
74937 }
74938
74939
74940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
74941   void * jresult ;
74942   Dali::Toolkit::TableView::Property *result = 0 ;
74943
74944   {
74945     try {
74946       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
74947     } catch (std::out_of_range& e) {
74948       {
74949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74950       };
74951     } catch (std::exception& e) {
74952       {
74953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74954       };
74955     } catch (...) {
74956       {
74957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74958       };
74959     }
74960   }
74961   jresult = (void *)result;
74962   return jresult;
74963 }
74964
74965
74966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
74967   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
74968
74969   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
74970   {
74971     try {
74972       delete arg1;
74973     } catch (std::out_of_range& e) {
74974       {
74975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74976       };
74977     } catch (std::exception& e) {
74978       {
74979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74980       };
74981     } catch (...) {
74982       {
74983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74984       };
74985     }
74986   }
74987 }
74988
74989
74990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
74991   int jresult ;
74992   int result;
74993
74994   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
74995   jresult = (int)result;
74996   return jresult;
74997 }
74998
74999
75000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
75001   int jresult ;
75002   int result;
75003
75004   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
75005   jresult = (int)result;
75006   return jresult;
75007 }
75008
75009
75010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
75011   int jresult ;
75012   int result;
75013
75014   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
75015   jresult = (int)result;
75016   return jresult;
75017 }
75018
75019
75020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
75021   int jresult ;
75022   int result;
75023
75024   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
75025   jresult = (int)result;
75026   return jresult;
75027 }
75028
75029
75030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
75031   int jresult ;
75032   int result;
75033
75034   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
75035   jresult = (int)result;
75036   return jresult;
75037 }
75038
75039
75040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
75041   void * jresult ;
75042   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
75043
75044   {
75045     try {
75046       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
75047     } catch (std::out_of_range& e) {
75048       {
75049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75050       };
75051     } catch (std::exception& e) {
75052       {
75053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75054       };
75055     } catch (...) {
75056       {
75057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75058       };
75059     }
75060   }
75061   jresult = (void *)result;
75062   return jresult;
75063 }
75064
75065
75066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
75067   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
75068
75069   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
75070   {
75071     try {
75072       delete arg1;
75073     } catch (std::out_of_range& e) {
75074       {
75075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75076       };
75077     } catch (std::exception& e) {
75078       {
75079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75080       };
75081     } catch (...) {
75082       {
75083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75084       };
75085     }
75086   }
75087 }
75088
75089
75090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
75091   void * jresult ;
75092   unsigned int arg1 ;
75093   unsigned int arg2 ;
75094   unsigned int arg3 ;
75095   unsigned int arg4 ;
75096   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75097
75098   arg1 = (unsigned int)jarg1;
75099   arg2 = (unsigned int)jarg2;
75100   arg3 = (unsigned int)jarg3;
75101   arg4 = (unsigned int)jarg4;
75102   {
75103     try {
75104       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
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 (...) {
75114       {
75115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75116       };
75117     }
75118   }
75119   jresult = (void *)result;
75120   return jresult;
75121 }
75122
75123
75124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
75125   void * jresult ;
75126   unsigned int arg1 ;
75127   unsigned int arg2 ;
75128   unsigned int arg3 ;
75129   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75130
75131   arg1 = (unsigned int)jarg1;
75132   arg2 = (unsigned int)jarg2;
75133   arg3 = (unsigned int)jarg3;
75134   {
75135     try {
75136       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
75137     } catch (std::out_of_range& e) {
75138       {
75139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75140       };
75141     } catch (std::exception& e) {
75142       {
75143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75144       };
75145     } catch (...) {
75146       {
75147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75148       };
75149     }
75150   }
75151   jresult = (void *)result;
75152   return jresult;
75153 }
75154
75155
75156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
75157   void * jresult ;
75158   unsigned int arg1 ;
75159   unsigned int arg2 ;
75160   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75161
75162   arg1 = (unsigned int)jarg1;
75163   arg2 = (unsigned int)jarg2;
75164   {
75165     try {
75166       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
75167     } catch (std::out_of_range& e) {
75168       {
75169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75170       };
75171     } catch (std::exception& e) {
75172       {
75173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75174       };
75175     } catch (...) {
75176       {
75177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75178       };
75179     }
75180   }
75181   jresult = (void *)result;
75182   return jresult;
75183 }
75184
75185
75186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
75187   void * jresult ;
75188   unsigned int arg1 ;
75189   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75190
75191   arg1 = (unsigned int)jarg1;
75192   {
75193     try {
75194       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
75195     } catch (std::out_of_range& e) {
75196       {
75197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75198       };
75199     } catch (std::exception& e) {
75200       {
75201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75202       };
75203     } catch (...) {
75204       {
75205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75206       };
75207     }
75208   }
75209   jresult = (void *)result;
75210   return jresult;
75211 }
75212
75213
75214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
75215   void * jresult ;
75216   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75217
75218   {
75219     try {
75220       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
75221     } catch (std::out_of_range& e) {
75222       {
75223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75224       };
75225     } catch (std::exception& e) {
75226       {
75227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75228       };
75229     } catch (...) {
75230       {
75231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75232       };
75233     }
75234   }
75235   jresult = (void *)result;
75236   return jresult;
75237 }
75238
75239
75240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
75241   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75242   unsigned int arg2 ;
75243
75244   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75245   arg2 = (unsigned int)jarg2;
75246   if (arg1) (arg1)->rowIndex = arg2;
75247 }
75248
75249
75250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
75251   unsigned int jresult ;
75252   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75253   unsigned int result;
75254
75255   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75256   result = (unsigned int) ((arg1)->rowIndex);
75257   jresult = result;
75258   return jresult;
75259 }
75260
75261
75262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
75263   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75264   unsigned int arg2 ;
75265
75266   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75267   arg2 = (unsigned int)jarg2;
75268   if (arg1) (arg1)->columnIndex = arg2;
75269 }
75270
75271
75272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
75273   unsigned int jresult ;
75274   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75275   unsigned int result;
75276
75277   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75278   result = (unsigned int) ((arg1)->columnIndex);
75279   jresult = result;
75280   return jresult;
75281 }
75282
75283
75284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
75285   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75286   unsigned int arg2 ;
75287
75288   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75289   arg2 = (unsigned int)jarg2;
75290   if (arg1) (arg1)->rowSpan = arg2;
75291 }
75292
75293
75294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
75295   unsigned int jresult ;
75296   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75297   unsigned int result;
75298
75299   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75300   result = (unsigned int) ((arg1)->rowSpan);
75301   jresult = result;
75302   return jresult;
75303 }
75304
75305
75306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
75307   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75308   unsigned int arg2 ;
75309
75310   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75311   arg2 = (unsigned int)jarg2;
75312   if (arg1) (arg1)->columnSpan = arg2;
75313 }
75314
75315
75316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
75317   unsigned int jresult ;
75318   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75319   unsigned int result;
75320
75321   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75322   result = (unsigned int) ((arg1)->columnSpan);
75323   jresult = result;
75324   return jresult;
75325 }
75326
75327
75328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
75329   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75330
75331   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75332   {
75333     try {
75334       delete arg1;
75335     } catch (std::out_of_range& e) {
75336       {
75337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75338       };
75339     } catch (std::exception& e) {
75340       {
75341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75342       };
75343     } catch (...) {
75344       {
75345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75346       };
75347     }
75348   }
75349 }
75350
75351
75352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
75353   void * jresult ;
75354   Dali::Toolkit::TableView *result = 0 ;
75355
75356   {
75357     try {
75358       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
75359     } catch (std::out_of_range& e) {
75360       {
75361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75362       };
75363     } catch (std::exception& e) {
75364       {
75365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75366       };
75367     } catch (...) {
75368       {
75369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75370       };
75371     }
75372   }
75373   jresult = (void *)result;
75374   return jresult;
75375 }
75376
75377
75378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
75379   void * jresult ;
75380   Dali::Toolkit::TableView *arg1 = 0 ;
75381   Dali::Toolkit::TableView *result = 0 ;
75382
75383   arg1 = (Dali::Toolkit::TableView *)jarg1;
75384   if (!arg1) {
75385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75386     return 0;
75387   }
75388   {
75389     try {
75390       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
75391     } catch (std::out_of_range& e) {
75392       {
75393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75394       };
75395     } catch (std::exception& e) {
75396       {
75397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75398       };
75399     } catch (...) {
75400       {
75401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75402       };
75403     }
75404   }
75405   jresult = (void *)result;
75406   return jresult;
75407 }
75408
75409
75410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
75411   void * jresult ;
75412   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75413   Dali::Toolkit::TableView *arg2 = 0 ;
75414   Dali::Toolkit::TableView *result = 0 ;
75415
75416   arg1 = (Dali::Toolkit::TableView *)jarg1;
75417   arg2 = (Dali::Toolkit::TableView *)jarg2;
75418   if (!arg2) {
75419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75420     return 0;
75421   }
75422   {
75423     try {
75424       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
75425     } catch (std::out_of_range& e) {
75426       {
75427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75428       };
75429     } catch (std::exception& e) {
75430       {
75431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75432       };
75433     } catch (...) {
75434       {
75435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75436       };
75437     }
75438   }
75439   jresult = (void *)result;
75440   return jresult;
75441 }
75442
75443
75444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
75445   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75446
75447   arg1 = (Dali::Toolkit::TableView *)jarg1;
75448   {
75449     try {
75450       delete arg1;
75451     } catch (std::out_of_range& e) {
75452       {
75453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75454       };
75455     } catch (std::exception& e) {
75456       {
75457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75458       };
75459     } catch (...) {
75460       {
75461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75462       };
75463     }
75464   }
75465 }
75466
75467
75468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
75469   void * jresult ;
75470   unsigned int arg1 ;
75471   unsigned int arg2 ;
75472   Dali::Toolkit::TableView result;
75473
75474   arg1 = (unsigned int)jarg1;
75475   arg2 = (unsigned int)jarg2;
75476   {
75477     try {
75478       result = Dali::Toolkit::TableView::New(arg1,arg2);
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 (...) {
75488       {
75489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75490       };
75491     }
75492   }
75493   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75494   return jresult;
75495 }
75496
75497
75498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
75499   void * jresult ;
75500   Dali::BaseHandle arg1 ;
75501   Dali::BaseHandle *argp1 ;
75502   Dali::Toolkit::TableView result;
75503
75504   argp1 = (Dali::BaseHandle *)jarg1;
75505   if (!argp1) {
75506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75507     return 0;
75508   }
75509   arg1 = *argp1;
75510   {
75511     try {
75512       result = Dali::Toolkit::TableView::DownCast(arg1);
75513     } catch (std::out_of_range& e) {
75514       {
75515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75516       };
75517     } catch (std::exception& e) {
75518       {
75519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75520       };
75521     } catch (...) {
75522       {
75523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75524       };
75525     }
75526   }
75527   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75528   return jresult;
75529 }
75530
75531
75532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
75533   unsigned int jresult ;
75534   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75535   Dali::Actor arg2 ;
75536   Dali::Toolkit::TableView::CellPosition arg3 ;
75537   Dali::Actor *argp2 ;
75538   Dali::Toolkit::TableView::CellPosition *argp3 ;
75539   bool result;
75540
75541   arg1 = (Dali::Toolkit::TableView *)jarg1;
75542   argp2 = (Dali::Actor *)jarg2;
75543   if (!argp2) {
75544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75545     return 0;
75546   }
75547   arg2 = *argp2;
75548   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75549   if (!argp3) {
75550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75551     return 0;
75552   }
75553   arg3 = *argp3;
75554   {
75555     try {
75556       result = (bool)(arg1)->AddChild(arg2,arg3);
75557     } catch (std::out_of_range& e) {
75558       {
75559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75560       };
75561     } catch (std::exception& e) {
75562       {
75563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75564       };
75565     } catch (...) {
75566       {
75567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75568       };
75569     }
75570   }
75571   jresult = result;
75572   return jresult;
75573 }
75574
75575
75576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
75577   void * jresult ;
75578   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75579   Dali::Toolkit::TableView::CellPosition arg2 ;
75580   Dali::Toolkit::TableView::CellPosition *argp2 ;
75581   Dali::Actor result;
75582
75583   arg1 = (Dali::Toolkit::TableView *)jarg1;
75584   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75585   if (!argp2) {
75586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75587     return 0;
75588   }
75589   arg2 = *argp2;
75590   {
75591     try {
75592       result = (arg1)->GetChildAt(arg2);
75593     } catch (std::out_of_range& e) {
75594       {
75595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75596       };
75597     } catch (std::exception& e) {
75598       {
75599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75600       };
75601     } catch (...) {
75602       {
75603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75604       };
75605     }
75606   }
75607   jresult = new Dali::Actor((const Dali::Actor &)result);
75608   return jresult;
75609 }
75610
75611
75612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
75613   void * jresult ;
75614   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75615   Dali::Toolkit::TableView::CellPosition arg2 ;
75616   Dali::Toolkit::TableView::CellPosition *argp2 ;
75617   Dali::Actor result;
75618
75619   arg1 = (Dali::Toolkit::TableView *)jarg1;
75620   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75621   if (!argp2) {
75622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75623     return 0;
75624   }
75625   arg2 = *argp2;
75626   {
75627     try {
75628       result = (arg1)->RemoveChildAt(arg2);
75629     } catch (std::out_of_range& e) {
75630       {
75631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75632       };
75633     } catch (std::exception& e) {
75634       {
75635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75636       };
75637     } catch (...) {
75638       {
75639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75640       };
75641     }
75642   }
75643   jresult = new Dali::Actor((const Dali::Actor &)result);
75644   return jresult;
75645 }
75646
75647
75648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
75649   unsigned int jresult ;
75650   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75651   Dali::Actor arg2 ;
75652   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
75653   Dali::Actor *argp2 ;
75654   bool result;
75655
75656   arg1 = (Dali::Toolkit::TableView *)jarg1;
75657   argp2 = (Dali::Actor *)jarg2;
75658   if (!argp2) {
75659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75660     return 0;
75661   }
75662   arg2 = *argp2;
75663   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75664   if (!arg3) {
75665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
75666     return 0;
75667   }
75668   {
75669     try {
75670       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
75671     } catch (std::out_of_range& e) {
75672       {
75673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75674       };
75675     } catch (std::exception& e) {
75676       {
75677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75678       };
75679     } catch (...) {
75680       {
75681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75682       };
75683     }
75684   }
75685   jresult = result;
75686   return jresult;
75687 }
75688
75689
75690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
75691   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75692   unsigned int arg2 ;
75693
75694   arg1 = (Dali::Toolkit::TableView *)jarg1;
75695   arg2 = (unsigned int)jarg2;
75696   {
75697     try {
75698       (arg1)->InsertRow(arg2);
75699     } catch (std::out_of_range& e) {
75700       {
75701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75702       };
75703     } catch (std::exception& e) {
75704       {
75705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75706       };
75707     } catch (...) {
75708       {
75709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75710       };
75711     }
75712   }
75713 }
75714
75715
75716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
75717   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75718   unsigned int arg2 ;
75719
75720   arg1 = (Dali::Toolkit::TableView *)jarg1;
75721   arg2 = (unsigned int)jarg2;
75722   {
75723     try {
75724       (arg1)->DeleteRow(arg2);
75725     } catch (std::out_of_range& e) {
75726       {
75727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75728       };
75729     } catch (std::exception& e) {
75730       {
75731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75732       };
75733     } catch (...) {
75734       {
75735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75736       };
75737     }
75738   }
75739 }
75740
75741
75742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75743   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75744   unsigned int arg2 ;
75745   std::vector< Dali::Actor > *arg3 = 0 ;
75746
75747   arg1 = (Dali::Toolkit::TableView *)jarg1;
75748   arg2 = (unsigned int)jarg2;
75749   arg3 = (std::vector< Dali::Actor > *)jarg3;
75750   if (!arg3) {
75751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75752     return ;
75753   }
75754   {
75755     try {
75756       (arg1)->DeleteRow(arg2,*arg3);
75757     } catch (std::out_of_range& e) {
75758       {
75759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75760       };
75761     } catch (std::exception& e) {
75762       {
75763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75764       };
75765     } catch (...) {
75766       {
75767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75768       };
75769     }
75770   }
75771 }
75772
75773
75774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
75775   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75776   unsigned int arg2 ;
75777
75778   arg1 = (Dali::Toolkit::TableView *)jarg1;
75779   arg2 = (unsigned int)jarg2;
75780   {
75781     try {
75782       (arg1)->InsertColumn(arg2);
75783     } catch (std::out_of_range& e) {
75784       {
75785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75786       };
75787     } catch (std::exception& e) {
75788       {
75789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75790       };
75791     } catch (...) {
75792       {
75793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75794       };
75795     }
75796   }
75797 }
75798
75799
75800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
75801   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75802   unsigned int arg2 ;
75803
75804   arg1 = (Dali::Toolkit::TableView *)jarg1;
75805   arg2 = (unsigned int)jarg2;
75806   {
75807     try {
75808       (arg1)->DeleteColumn(arg2);
75809     } catch (std::out_of_range& e) {
75810       {
75811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75812       };
75813     } catch (std::exception& e) {
75814       {
75815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75816       };
75817     } catch (...) {
75818       {
75819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75820       };
75821     }
75822   }
75823 }
75824
75825
75826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75827   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75828   unsigned int arg2 ;
75829   std::vector< Dali::Actor > *arg3 = 0 ;
75830
75831   arg1 = (Dali::Toolkit::TableView *)jarg1;
75832   arg2 = (unsigned int)jarg2;
75833   arg3 = (std::vector< Dali::Actor > *)jarg3;
75834   if (!arg3) {
75835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75836     return ;
75837   }
75838   {
75839     try {
75840       (arg1)->DeleteColumn(arg2,*arg3);
75841     } catch (std::out_of_range& e) {
75842       {
75843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75844       };
75845     } catch (std::exception& e) {
75846       {
75847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75848       };
75849     } catch (...) {
75850       {
75851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75852       };
75853     }
75854   }
75855 }
75856
75857
75858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
75859   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75860   unsigned int arg2 ;
75861   unsigned int arg3 ;
75862
75863   arg1 = (Dali::Toolkit::TableView *)jarg1;
75864   arg2 = (unsigned int)jarg2;
75865   arg3 = (unsigned int)jarg3;
75866   {
75867     try {
75868       (arg1)->Resize(arg2,arg3);
75869     } catch (std::out_of_range& e) {
75870       {
75871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75872       };
75873     } catch (std::exception& e) {
75874       {
75875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75876       };
75877     } catch (...) {
75878       {
75879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75880       };
75881     }
75882   }
75883 }
75884
75885
75886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
75887   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75888   unsigned int arg2 ;
75889   unsigned int arg3 ;
75890   std::vector< Dali::Actor > *arg4 = 0 ;
75891
75892   arg1 = (Dali::Toolkit::TableView *)jarg1;
75893   arg2 = (unsigned int)jarg2;
75894   arg3 = (unsigned int)jarg3;
75895   arg4 = (std::vector< Dali::Actor > *)jarg4;
75896   if (!arg4) {
75897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75898     return ;
75899   }
75900   {
75901     try {
75902       (arg1)->Resize(arg2,arg3,*arg4);
75903     } catch (std::out_of_range& e) {
75904       {
75905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75906       };
75907     } catch (std::exception& e) {
75908       {
75909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75910       };
75911     } catch (...) {
75912       {
75913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75914       };
75915     }
75916   }
75917 }
75918
75919
75920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
75921   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75922   Dali::Size arg2 ;
75923   Dali::Size *argp2 ;
75924
75925   arg1 = (Dali::Toolkit::TableView *)jarg1;
75926   argp2 = (Dali::Size *)jarg2;
75927   if (!argp2) {
75928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
75929     return ;
75930   }
75931   arg2 = *argp2;
75932   {
75933     try {
75934       (arg1)->SetCellPadding(arg2);
75935     } catch (std::out_of_range& e) {
75936       {
75937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75938       };
75939     } catch (std::exception& e) {
75940       {
75941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75942       };
75943     } catch (...) {
75944       {
75945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75946       };
75947     }
75948   }
75949 }
75950
75951
75952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
75953   void * jresult ;
75954   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75955   Dali::Size result;
75956
75957   arg1 = (Dali::Toolkit::TableView *)jarg1;
75958   {
75959     try {
75960       result = (arg1)->GetCellPadding();
75961     } catch (std::out_of_range& e) {
75962       {
75963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75964       };
75965     } catch (std::exception& e) {
75966       {
75967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75968       };
75969     } catch (...) {
75970       {
75971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75972       };
75973     }
75974   }
75975   jresult = new Dali::Size((const Dali::Size &)result);
75976   return jresult;
75977 }
75978
75979
75980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
75981   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75982   unsigned int arg2 ;
75983
75984   arg1 = (Dali::Toolkit::TableView *)jarg1;
75985   arg2 = (unsigned int)jarg2;
75986   {
75987     try {
75988       (arg1)->SetFitHeight(arg2);
75989     } catch (std::out_of_range& e) {
75990       {
75991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75992       };
75993     } catch (std::exception& e) {
75994       {
75995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75996       };
75997     } catch (...) {
75998       {
75999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76000       };
76001     }
76002   }
76003 }
76004
76005
76006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
76007   unsigned int jresult ;
76008   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76009   unsigned int arg2 ;
76010   bool result;
76011
76012   arg1 = (Dali::Toolkit::TableView *)jarg1;
76013   arg2 = (unsigned int)jarg2;
76014   {
76015     try {
76016       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
76017     } catch (std::out_of_range& e) {
76018       {
76019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76020       };
76021     } catch (std::exception& e) {
76022       {
76023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76024       };
76025     } catch (...) {
76026       {
76027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76028       };
76029     }
76030   }
76031   jresult = result;
76032   return jresult;
76033 }
76034
76035
76036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
76037   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76038   unsigned int arg2 ;
76039
76040   arg1 = (Dali::Toolkit::TableView *)jarg1;
76041   arg2 = (unsigned int)jarg2;
76042   {
76043     try {
76044       (arg1)->SetFitWidth(arg2);
76045     } catch (std::out_of_range& e) {
76046       {
76047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76048       };
76049     } catch (std::exception& e) {
76050       {
76051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76052       };
76053     } catch (...) {
76054       {
76055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76056       };
76057     }
76058   }
76059 }
76060
76061
76062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
76063   unsigned int jresult ;
76064   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76065   unsigned int arg2 ;
76066   bool result;
76067
76068   arg1 = (Dali::Toolkit::TableView *)jarg1;
76069   arg2 = (unsigned int)jarg2;
76070   {
76071     try {
76072       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
76073     } catch (std::out_of_range& e) {
76074       {
76075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76076       };
76077     } catch (std::exception& e) {
76078       {
76079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76080       };
76081     } catch (...) {
76082       {
76083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76084       };
76085     }
76086   }
76087   jresult = result;
76088   return jresult;
76089 }
76090
76091
76092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76093   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76094   unsigned int arg2 ;
76095   float arg3 ;
76096
76097   arg1 = (Dali::Toolkit::TableView *)jarg1;
76098   arg2 = (unsigned int)jarg2;
76099   arg3 = (float)jarg3;
76100   {
76101     try {
76102       (arg1)->SetFixedHeight(arg2,arg3);
76103     } catch (std::out_of_range& e) {
76104       {
76105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76106       };
76107     } catch (std::exception& e) {
76108       {
76109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76110       };
76111     } catch (...) {
76112       {
76113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76114       };
76115     }
76116   }
76117 }
76118
76119
76120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
76121   float jresult ;
76122   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76123   unsigned int arg2 ;
76124   float result;
76125
76126   arg1 = (Dali::Toolkit::TableView *)jarg1;
76127   arg2 = (unsigned int)jarg2;
76128   {
76129     try {
76130       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
76131     } catch (std::out_of_range& e) {
76132       {
76133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76134       };
76135     } catch (std::exception& e) {
76136       {
76137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76138       };
76139     } catch (...) {
76140       {
76141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76142       };
76143     }
76144   }
76145   jresult = result;
76146   return jresult;
76147 }
76148
76149
76150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76151   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76152   unsigned int arg2 ;
76153   float arg3 ;
76154
76155   arg1 = (Dali::Toolkit::TableView *)jarg1;
76156   arg2 = (unsigned int)jarg2;
76157   arg3 = (float)jarg3;
76158   {
76159     try {
76160       (arg1)->SetRelativeHeight(arg2,arg3);
76161     } catch (std::out_of_range& e) {
76162       {
76163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76164       };
76165     } catch (std::exception& e) {
76166       {
76167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76168       };
76169     } catch (...) {
76170       {
76171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76172       };
76173     }
76174   }
76175 }
76176
76177
76178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
76179   float jresult ;
76180   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76181   unsigned int arg2 ;
76182   float result;
76183
76184   arg1 = (Dali::Toolkit::TableView *)jarg1;
76185   arg2 = (unsigned int)jarg2;
76186   {
76187     try {
76188       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
76189     } catch (std::out_of_range& e) {
76190       {
76191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76192       };
76193     } catch (std::exception& e) {
76194       {
76195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76196       };
76197     } catch (...) {
76198       {
76199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76200       };
76201     }
76202   }
76203   jresult = result;
76204   return jresult;
76205 }
76206
76207
76208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76209   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76210   unsigned int arg2 ;
76211   float arg3 ;
76212
76213   arg1 = (Dali::Toolkit::TableView *)jarg1;
76214   arg2 = (unsigned int)jarg2;
76215   arg3 = (float)jarg3;
76216   {
76217     try {
76218       (arg1)->SetFixedWidth(arg2,arg3);
76219     } catch (std::out_of_range& e) {
76220       {
76221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76222       };
76223     } catch (std::exception& e) {
76224       {
76225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76226       };
76227     } catch (...) {
76228       {
76229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76230       };
76231     }
76232   }
76233 }
76234
76235
76236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
76237   float jresult ;
76238   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76239   unsigned int arg2 ;
76240   float result;
76241
76242   arg1 = (Dali::Toolkit::TableView *)jarg1;
76243   arg2 = (unsigned int)jarg2;
76244   {
76245     try {
76246       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
76247     } catch (std::out_of_range& e) {
76248       {
76249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76250       };
76251     } catch (std::exception& e) {
76252       {
76253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76254       };
76255     } catch (...) {
76256       {
76257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76258       };
76259     }
76260   }
76261   jresult = result;
76262   return jresult;
76263 }
76264
76265
76266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76267   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76268   unsigned int arg2 ;
76269   float arg3 ;
76270
76271   arg1 = (Dali::Toolkit::TableView *)jarg1;
76272   arg2 = (unsigned int)jarg2;
76273   arg3 = (float)jarg3;
76274   {
76275     try {
76276       (arg1)->SetRelativeWidth(arg2,arg3);
76277     } catch (std::out_of_range& e) {
76278       {
76279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76280       };
76281     } catch (std::exception& e) {
76282       {
76283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76284       };
76285     } catch (...) {
76286       {
76287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76288       };
76289     }
76290   }
76291 }
76292
76293
76294 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
76295   float jresult ;
76296   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76297   unsigned int arg2 ;
76298   float result;
76299
76300   arg1 = (Dali::Toolkit::TableView *)jarg1;
76301   arg2 = (unsigned int)jarg2;
76302   {
76303     try {
76304       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
76305     } catch (std::out_of_range& e) {
76306       {
76307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76308       };
76309     } catch (std::exception& e) {
76310       {
76311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76312       };
76313     } catch (...) {
76314       {
76315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76316       };
76317     }
76318   }
76319   jresult = result;
76320   return jresult;
76321 }
76322
76323
76324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
76325   unsigned int jresult ;
76326   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76327   unsigned int result;
76328
76329   arg1 = (Dali::Toolkit::TableView *)jarg1;
76330   {
76331     try {
76332       result = (unsigned int)(arg1)->GetRows();
76333     } catch (std::out_of_range& e) {
76334       {
76335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76336       };
76337     } catch (std::exception& e) {
76338       {
76339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76340       };
76341     } catch (...) {
76342       {
76343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76344       };
76345     }
76346   }
76347   jresult = result;
76348   return jresult;
76349 }
76350
76351
76352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
76353   unsigned int jresult ;
76354   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76355   unsigned int result;
76356
76357   arg1 = (Dali::Toolkit::TableView *)jarg1;
76358   {
76359     try {
76360       result = (unsigned int)(arg1)->GetColumns();
76361     } catch (std::out_of_range& e) {
76362       {
76363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76364       };
76365     } catch (std::exception& e) {
76366       {
76367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76368       };
76369     } catch (...) {
76370       {
76371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76372       };
76373     }
76374   }
76375   jresult = result;
76376   return jresult;
76377 }
76378
76379
76380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
76381   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76382   Dali::Toolkit::TableView::CellPosition arg2 ;
76383   Dali::HorizontalAlignment::Type arg3 ;
76384   Dali::VerticalAlignment::Type arg4 ;
76385   Dali::Toolkit::TableView::CellPosition *argp2 ;
76386
76387   arg1 = (Dali::Toolkit::TableView *)jarg1;
76388   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76389   if (!argp2) {
76390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76391     return ;
76392   }
76393   arg2 = *argp2;
76394   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
76395   arg4 = (Dali::VerticalAlignment::Type)jarg4;
76396   {
76397     try {
76398       (arg1)->SetCellAlignment(arg2,arg3,arg4);
76399     } catch (std::out_of_range& e) {
76400       {
76401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76402       };
76403     } catch (std::exception& e) {
76404       {
76405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76406       };
76407     } catch (...) {
76408       {
76409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76410       };
76411     }
76412   }
76413 }
76414
76415
76416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
76417   unsigned int jresult ;
76418   unsigned int result;
76419
76420   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
76421   jresult = result;
76422   return jresult;
76423 }
76424
76425
76426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
76427   int jresult ;
76428   int result;
76429
76430   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
76431   jresult = (int)result;
76432   return jresult;
76433 }
76434
76435
76436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
76437   int jresult ;
76438   int result;
76439
76440   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
76441   jresult = (int)result;
76442   return jresult;
76443 }
76444
76445
76446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
76447   int jresult ;
76448   int result;
76449
76450   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
76451   jresult = (int)result;
76452   return jresult;
76453 }
76454
76455
76456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
76457   int jresult ;
76458   int result;
76459
76460   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
76461   jresult = (int)result;
76462   return jresult;
76463 }
76464
76465
76466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
76467   int jresult ;
76468   int result;
76469
76470   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
76471   jresult = (int)result;
76472   return jresult;
76473 }
76474
76475
76476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
76477   int jresult ;
76478   int result;
76479
76480   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
76481   jresult = (int)result;
76482   return jresult;
76483 }
76484
76485
76486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
76487   int jresult ;
76488   int result;
76489
76490   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
76491   jresult = (int)result;
76492   return jresult;
76493 }
76494
76495
76496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
76497   int jresult ;
76498   int result;
76499
76500   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
76501   jresult = (int)result;
76502   return jresult;
76503 }
76504
76505
76506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
76507   int jresult ;
76508   int result;
76509
76510   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
76511   jresult = (int)result;
76512   return jresult;
76513 }
76514
76515
76516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
76517   int jresult ;
76518   int result;
76519
76520   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
76521   jresult = (int)result;
76522   return jresult;
76523 }
76524
76525
76526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
76527   int jresult ;
76528   int result;
76529
76530   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
76531   jresult = (int)result;
76532   return jresult;
76533 }
76534
76535
76536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
76537   int jresult ;
76538   int result;
76539
76540   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
76541   jresult = (int)result;
76542   return jresult;
76543 }
76544
76545
76546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
76547   int jresult ;
76548   int result;
76549
76550   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
76551   jresult = (int)result;
76552   return jresult;
76553 }
76554
76555
76556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
76557   int jresult ;
76558   int result;
76559
76560   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
76561   jresult = (int)result;
76562   return jresult;
76563 }
76564
76565
76566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
76567   int jresult ;
76568   int result;
76569
76570   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
76571   jresult = (int)result;
76572   return jresult;
76573 }
76574
76575
76576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
76577   int jresult ;
76578   int result;
76579
76580   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
76581   jresult = (int)result;
76582   return jresult;
76583 }
76584
76585
76586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
76587   int jresult ;
76588   int result;
76589
76590   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
76591   jresult = (int)result;
76592   return jresult;
76593 }
76594
76595
76596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
76597   int jresult ;
76598   int result;
76599
76600   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
76601   jresult = (int)result;
76602   return jresult;
76603 }
76604
76605
76606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
76607   int jresult ;
76608   int result;
76609
76610   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
76611   jresult = (int)result;
76612   return jresult;
76613 }
76614
76615
76616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
76617   int jresult ;
76618   int result;
76619
76620   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
76621   jresult = (int)result;
76622   return jresult;
76623 }
76624
76625
76626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
76627   int jresult ;
76628   int result;
76629
76630   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
76631   jresult = (int)result;
76632   return jresult;
76633 }
76634
76635
76636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
76637   int jresult ;
76638   int result;
76639
76640   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
76641   jresult = (int)result;
76642   return jresult;
76643 }
76644
76645
76646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
76647   int jresult ;
76648   int result;
76649
76650   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
76651   jresult = (int)result;
76652   return jresult;
76653 }
76654
76655
76656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
76657   int jresult ;
76658   int result;
76659
76660   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
76661   jresult = (int)result;
76662   return jresult;
76663 }
76664
76665
76666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
76667   int jresult ;
76668   int result;
76669
76670   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
76671   jresult = (int)result;
76672   return jresult;
76673 }
76674
76675
76676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
76677   int jresult ;
76678   int result;
76679
76680   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
76681   jresult = (int)result;
76682   return jresult;
76683 }
76684
76685
76686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
76687   int jresult ;
76688   int result;
76689
76690   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
76691   jresult = (int)result;
76692   return jresult;
76693 }
76694
76695
76696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
76697   int jresult ;
76698   int result;
76699
76700   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
76701   jresult = (int)result;
76702   return jresult;
76703 }
76704
76705
76706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
76707   int jresult ;
76708   int result;
76709
76710   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
76711   jresult = (int)result;
76712   return jresult;
76713 }
76714
76715
76716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
76717   int jresult ;
76718   int result;
76719
76720   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
76721   jresult = (int)result;
76722   return jresult;
76723 }
76724
76725
76726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
76727   int jresult ;
76728   int result;
76729
76730   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
76731   jresult = (int)result;
76732   return jresult;
76733 }
76734
76735
76736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
76737   int jresult ;
76738   int result;
76739
76740   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
76741   jresult = (int)result;
76742   return jresult;
76743 }
76744
76745
76746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
76747   int jresult ;
76748   int result;
76749
76750   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
76751   jresult = (int)result;
76752   return jresult;
76753 }
76754
76755
76756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
76757   int jresult ;
76758   int result;
76759
76760   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
76761   jresult = (int)result;
76762   return jresult;
76763 }
76764
76765
76766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
76767   int jresult ;
76768   int result;
76769
76770   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
76771   jresult = (int)result;
76772   return jresult;
76773 }
76774
76775
76776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
76777   int jresult ;
76778   int result;
76779
76780   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
76781   jresult = (int)result;
76782   return jresult;
76783 }
76784
76785
76786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
76787   int jresult ;
76788   int result;
76789
76790   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
76791   jresult = (int)result;
76792   return jresult;
76793 }
76794
76795
76796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
76797   int jresult ;
76798   int result;
76799
76800   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
76801   jresult = (int)result;
76802   return jresult;
76803 }
76804
76805
76806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
76807   int jresult ;
76808   int result;
76809
76810   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
76811   jresult = (int)result;
76812   return jresult;
76813 }
76814
76815
76816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
76817   int jresult ;
76818   int result;
76819
76820   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
76821   jresult = (int)result;
76822   return jresult;
76823 }
76824
76825
76826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
76827   void * jresult ;
76828   Dali::Toolkit::TextEditor::Property *result = 0 ;
76829
76830   {
76831     try {
76832       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
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 (...) {
76842       {
76843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76844       };
76845     }
76846   }
76847   jresult = (void *)result;
76848   return jresult;
76849 }
76850
76851
76852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
76853   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
76854
76855   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
76856   {
76857     try {
76858       delete arg1;
76859     } catch (std::out_of_range& e) {
76860       {
76861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76862       };
76863     } catch (std::exception& e) {
76864       {
76865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76866       };
76867     } catch (...) {
76868       {
76869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76870       };
76871     }
76872   }
76873 }
76874
76875
76876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
76877   void * jresult ;
76878   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
76879
76880   {
76881     try {
76882       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
76883     } catch (std::out_of_range& e) {
76884       {
76885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76886       };
76887     } catch (std::exception& e) {
76888       {
76889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76890       };
76891     } catch (...) {
76892       {
76893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76894       };
76895     }
76896   }
76897   jresult = (void *)result;
76898   return jresult;
76899 }
76900
76901
76902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
76903   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
76904
76905   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
76906   {
76907     try {
76908       delete arg1;
76909     } catch (std::out_of_range& e) {
76910       {
76911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76912       };
76913     } catch (std::exception& e) {
76914       {
76915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76916       };
76917     } catch (...) {
76918       {
76919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76920       };
76921     }
76922   }
76923 }
76924
76925
76926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
76927   void * jresult ;
76928   Dali::Toolkit::TextEditor result;
76929
76930   {
76931     try {
76932       result = Dali::Toolkit::TextEditor::New();
76933     } catch (std::out_of_range& e) {
76934       {
76935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76936       };
76937     } catch (std::exception& e) {
76938       {
76939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76940       };
76941     } catch (...) {
76942       {
76943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76944       };
76945     }
76946   }
76947   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
76948   return jresult;
76949 }
76950
76951
76952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
76953   void * jresult ;
76954   Dali::Toolkit::TextEditor *result = 0 ;
76955
76956   {
76957     try {
76958       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
76959     } catch (std::out_of_range& e) {
76960       {
76961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76962       };
76963     } catch (std::exception& e) {
76964       {
76965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76966       };
76967     } catch (...) {
76968       {
76969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76970       };
76971     }
76972   }
76973   jresult = (void *)result;
76974   return jresult;
76975 }
76976
76977
76978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
76979   void * jresult ;
76980   Dali::Toolkit::TextEditor *arg1 = 0 ;
76981   Dali::Toolkit::TextEditor *result = 0 ;
76982
76983   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
76984   if (!arg1) {
76985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
76986     return 0;
76987   }
76988   {
76989     try {
76990       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
76991     } catch (std::out_of_range& e) {
76992       {
76993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76994       };
76995     } catch (std::exception& e) {
76996       {
76997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76998       };
76999     } catch (...) {
77000       {
77001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77002       };
77003     }
77004   }
77005   jresult = (void *)result;
77006   return jresult;
77007 }
77008
77009
77010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
77011   void * jresult ;
77012   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77013   Dali::Toolkit::TextEditor *arg2 = 0 ;
77014   Dali::Toolkit::TextEditor *result = 0 ;
77015
77016   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77017   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
77018   if (!arg2) {
77019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77020     return 0;
77021   }
77022   {
77023     try {
77024       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
77025     } catch (std::out_of_range& e) {
77026       {
77027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77028       };
77029     } catch (std::exception& e) {
77030       {
77031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77032       };
77033     } catch (...) {
77034       {
77035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77036       };
77037     }
77038   }
77039   jresult = (void *)result;
77040   return jresult;
77041 }
77042
77043
77044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
77045   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77046
77047   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77048   {
77049     try {
77050       delete arg1;
77051     } catch (std::out_of_range& e) {
77052       {
77053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77054       };
77055     } catch (std::exception& e) {
77056       {
77057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77058       };
77059     } catch (...) {
77060       {
77061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77062       };
77063     }
77064   }
77065 }
77066
77067
77068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
77069   void * jresult ;
77070   Dali::BaseHandle arg1 ;
77071   Dali::BaseHandle *argp1 ;
77072   Dali::Toolkit::TextEditor result;
77073
77074   argp1 = (Dali::BaseHandle *)jarg1;
77075   if (!argp1) {
77076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77077     return 0;
77078   }
77079   arg1 = *argp1;
77080   {
77081     try {
77082       result = Dali::Toolkit::TextEditor::DownCast(arg1);
77083     } catch (std::out_of_range& e) {
77084       {
77085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77086       };
77087     } catch (std::exception& e) {
77088       {
77089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77090       };
77091     } catch (...) {
77092       {
77093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77094       };
77095     }
77096   }
77097   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77098   return jresult;
77099 }
77100
77101
77102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
77103   void * jresult ;
77104   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77105   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
77106
77107   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77108   {
77109     try {
77110       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
77111     } catch (std::out_of_range& e) {
77112       {
77113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77114       };
77115     } catch (std::exception& e) {
77116       {
77117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77118       };
77119     } catch (...) {
77120       {
77121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77122       };
77123     }
77124   }
77125   jresult = (void *)result;
77126   return jresult;
77127 }
77128
77129
77130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
77131   void * jresult ;
77132   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77133   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
77134
77135   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77136   {
77137     try {
77138       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
77139     } catch (std::out_of_range& e) {
77140       {
77141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77142       };
77143     } catch (std::exception& e) {
77144       {
77145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77146       };
77147     } catch (...) {
77148       {
77149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77150       };
77151     }
77152   }
77153   jresult = (void *)result;
77154   return jresult;
77155 }
77156
77157
77158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
77159   int jresult ;
77160   int result;
77161
77162   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
77163   jresult = (int)result;
77164   return jresult;
77165 }
77166
77167
77168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
77169   int jresult ;
77170   int result;
77171
77172   result = (int)Dali::Toolkit::TextField::Property::TEXT;
77173   jresult = (int)result;
77174   return jresult;
77175 }
77176
77177
77178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
77179   int jresult ;
77180   int result;
77181
77182   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
77183   jresult = (int)result;
77184   return jresult;
77185 }
77186
77187
77188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
77189   int jresult ;
77190   int result;
77191
77192   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
77193   jresult = (int)result;
77194   return jresult;
77195 }
77196
77197
77198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
77199   int jresult ;
77200   int result;
77201
77202   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
77203   jresult = (int)result;
77204   return jresult;
77205 }
77206
77207
77208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
77209   int jresult ;
77210   int result;
77211
77212   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
77213   jresult = (int)result;
77214   return jresult;
77215 }
77216
77217
77218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
77219   int jresult ;
77220   int result;
77221
77222   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
77223   jresult = (int)result;
77224   return jresult;
77225 }
77226
77227
77228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
77229   int jresult ;
77230   int result;
77231
77232   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
77233   jresult = (int)result;
77234   return jresult;
77235 }
77236
77237
77238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
77239   int jresult ;
77240   int result;
77241
77242   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
77243   jresult = (int)result;
77244   return jresult;
77245 }
77246
77247
77248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
77249   int jresult ;
77250   int result;
77251
77252   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
77253   jresult = (int)result;
77254   return jresult;
77255 }
77256
77257
77258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
77259   int jresult ;
77260   int result;
77261
77262   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
77263   jresult = (int)result;
77264   return jresult;
77265 }
77266
77267
77268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
77269   int jresult ;
77270   int result;
77271
77272   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
77273   jresult = (int)result;
77274   return jresult;
77275 }
77276
77277
77278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
77279   int jresult ;
77280   int result;
77281
77282   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
77283   jresult = (int)result;
77284   return jresult;
77285 }
77286
77287
77288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
77289   int jresult ;
77290   int result;
77291
77292   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
77293   jresult = (int)result;
77294   return jresult;
77295 }
77296
77297
77298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
77299   int jresult ;
77300   int result;
77301
77302   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
77303   jresult = (int)result;
77304   return jresult;
77305 }
77306
77307
77308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
77309   int jresult ;
77310   int result;
77311
77312   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
77313   jresult = (int)result;
77314   return jresult;
77315 }
77316
77317
77318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
77319   int jresult ;
77320   int result;
77321
77322   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
77323   jresult = (int)result;
77324   return jresult;
77325 }
77326
77327
77328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
77329   int jresult ;
77330   int result;
77331
77332   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
77333   jresult = (int)result;
77334   return jresult;
77335 }
77336
77337
77338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
77339   int jresult ;
77340   int result;
77341
77342   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
77343   jresult = (int)result;
77344   return jresult;
77345 }
77346
77347
77348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
77349   int jresult ;
77350   int result;
77351
77352   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
77353   jresult = (int)result;
77354   return jresult;
77355 }
77356
77357
77358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
77359   int jresult ;
77360   int result;
77361
77362   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
77363   jresult = (int)result;
77364   return jresult;
77365 }
77366
77367
77368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
77369   int jresult ;
77370   int result;
77371
77372   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
77373   jresult = (int)result;
77374   return jresult;
77375 }
77376
77377
77378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77379   int jresult ;
77380   int result;
77381
77382   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
77383   jresult = (int)result;
77384   return jresult;
77385 }
77386
77387
77388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
77389   int jresult ;
77390   int result;
77391
77392   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
77393   jresult = (int)result;
77394   return jresult;
77395 }
77396
77397
77398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
77399   int jresult ;
77400   int result;
77401
77402   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
77403   jresult = (int)result;
77404   return jresult;
77405 }
77406
77407
77408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77409   int jresult ;
77410   int result;
77411
77412   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
77413   jresult = (int)result;
77414   return jresult;
77415 }
77416
77417
77418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77419   int jresult ;
77420   int result;
77421
77422   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77423   jresult = (int)result;
77424   return jresult;
77425 }
77426
77427
77428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77429   int jresult ;
77430   int result;
77431
77432   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77433   jresult = (int)result;
77434   return jresult;
77435 }
77436
77437
77438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77439   int jresult ;
77440   int result;
77441
77442   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77443   jresult = (int)result;
77444   return jresult;
77445 }
77446
77447
77448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77449   int jresult ;
77450   int result;
77451
77452   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77453   jresult = (int)result;
77454   return jresult;
77455 }
77456
77457
77458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77459   int jresult ;
77460   int result;
77461
77462   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77463   jresult = (int)result;
77464   return jresult;
77465 }
77466
77467
77468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77469   int jresult ;
77470   int result;
77471
77472   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
77473   jresult = (int)result;
77474   return jresult;
77475 }
77476
77477
77478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
77479   int jresult ;
77480   int result;
77481
77482   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
77483   jresult = (int)result;
77484   return jresult;
77485 }
77486
77487
77488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
77489   int jresult ;
77490   int result;
77491
77492   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
77493   jresult = (int)result;
77494   return jresult;
77495 }
77496
77497
77498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
77499   int jresult ;
77500   int result;
77501
77502   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
77503   jresult = (int)result;
77504   return jresult;
77505 }
77506
77507
77508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
77509   int jresult ;
77510   int result;
77511
77512   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
77513   jresult = (int)result;
77514   return jresult;
77515 }
77516
77517
77518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
77519   int jresult ;
77520   int result;
77521
77522   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
77523   jresult = (int)result;
77524   return jresult;
77525 }
77526
77527
77528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
77529   int jresult ;
77530   int result;
77531
77532   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
77533   jresult = (int)result;
77534   return jresult;
77535 }
77536
77537
77538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
77539   int jresult ;
77540   int result;
77541
77542   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
77543   jresult = (int)result;
77544   return jresult;
77545 }
77546
77547
77548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
77549   int jresult ;
77550   int result;
77551
77552   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
77553   jresult = (int)result;
77554   return jresult;
77555 }
77556
77557
77558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
77559   int jresult ;
77560   int result;
77561
77562   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
77563   jresult = (int)result;
77564   return jresult;
77565 }
77566
77567
77568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
77569   int jresult ;
77570   int result;
77571
77572   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
77573   jresult = (int)result;
77574   return jresult;
77575 }
77576
77577
77578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
77579   int jresult ;
77580   int result;
77581
77582   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
77583   jresult = (int)result;
77584   return jresult;
77585 }
77586
77587
77588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
77589   int jresult ;
77590   int result;
77591
77592   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
77593   jresult = (int)result;
77594   return jresult;
77595 }
77596
77597
77598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
77599   int jresult ;
77600   int result;
77601
77602   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
77603   jresult = (int)result;
77604   return jresult;
77605 }
77606
77607
77608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
77609   int jresult ;
77610   int result;
77611
77612   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
77613   jresult = (int)result;
77614   return jresult;
77615 }
77616
77617
77618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
77619   int jresult ;
77620   int result;
77621
77622   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
77623   jresult = (int)result;
77624   return jresult;
77625 }
77626
77627
77628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
77629   void * jresult ;
77630   Dali::Toolkit::TextField::Property *result = 0 ;
77631
77632   {
77633     try {
77634       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
77635     } catch (std::out_of_range& e) {
77636       {
77637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77638       };
77639     } catch (std::exception& e) {
77640       {
77641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77642       };
77643     } catch (...) {
77644       {
77645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77646       };
77647     }
77648   }
77649   jresult = (void *)result;
77650   return jresult;
77651 }
77652
77653
77654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
77655   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
77656
77657   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
77658   {
77659     try {
77660       delete arg1;
77661     } catch (std::out_of_range& e) {
77662       {
77663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77664       };
77665     } catch (std::exception& e) {
77666       {
77667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77668       };
77669     } catch (...) {
77670       {
77671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77672       };
77673     }
77674   }
77675 }
77676
77677
77678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
77679   void * jresult ;
77680   Dali::Toolkit::TextField::InputStyle *result = 0 ;
77681
77682   {
77683     try {
77684       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
77685     } catch (std::out_of_range& e) {
77686       {
77687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77688       };
77689     } catch (std::exception& e) {
77690       {
77691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77692       };
77693     } catch (...) {
77694       {
77695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77696       };
77697     }
77698   }
77699   jresult = (void *)result;
77700   return jresult;
77701 }
77702
77703
77704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
77705   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
77706
77707   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
77708   {
77709     try {
77710       delete arg1;
77711     } catch (std::out_of_range& e) {
77712       {
77713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77714       };
77715     } catch (std::exception& e) {
77716       {
77717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77718       };
77719     } catch (...) {
77720       {
77721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77722       };
77723     }
77724   }
77725 }
77726
77727
77728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
77729   void * jresult ;
77730   Dali::Toolkit::TextField result;
77731
77732   {
77733     try {
77734       result = Dali::Toolkit::TextField::New();
77735     } catch (std::out_of_range& e) {
77736       {
77737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77738       };
77739     } catch (std::exception& e) {
77740       {
77741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77742       };
77743     } catch (...) {
77744       {
77745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77746       };
77747     }
77748   }
77749   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
77750   return jresult;
77751 }
77752
77753
77754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
77755   void * jresult ;
77756   Dali::Toolkit::TextField *result = 0 ;
77757
77758   {
77759     try {
77760       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
77761     } catch (std::out_of_range& e) {
77762       {
77763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77764       };
77765     } catch (std::exception& e) {
77766       {
77767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77768       };
77769     } catch (...) {
77770       {
77771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77772       };
77773     }
77774   }
77775   jresult = (void *)result;
77776   return jresult;
77777 }
77778
77779
77780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
77781   void * jresult ;
77782   Dali::Toolkit::TextField *arg1 = 0 ;
77783   Dali::Toolkit::TextField *result = 0 ;
77784
77785   arg1 = (Dali::Toolkit::TextField *)jarg1;
77786   if (!arg1) {
77787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77788     return 0;
77789   }
77790   {
77791     try {
77792       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
77793     } catch (std::out_of_range& e) {
77794       {
77795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77796       };
77797     } catch (std::exception& e) {
77798       {
77799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77800       };
77801     } catch (...) {
77802       {
77803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77804       };
77805     }
77806   }
77807   jresult = (void *)result;
77808   return jresult;
77809 }
77810
77811
77812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
77813   void * jresult ;
77814   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77815   Dali::Toolkit::TextField *arg2 = 0 ;
77816   Dali::Toolkit::TextField *result = 0 ;
77817
77818   arg1 = (Dali::Toolkit::TextField *)jarg1;
77819   arg2 = (Dali::Toolkit::TextField *)jarg2;
77820   if (!arg2) {
77821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
77822     return 0;
77823   }
77824   {
77825     try {
77826       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
77827     } catch (std::out_of_range& e) {
77828       {
77829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77830       };
77831     } catch (std::exception& e) {
77832       {
77833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77834       };
77835     } catch (...) {
77836       {
77837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77838       };
77839     }
77840   }
77841   jresult = (void *)result;
77842   return jresult;
77843 }
77844
77845
77846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
77847   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77848
77849   arg1 = (Dali::Toolkit::TextField *)jarg1;
77850   {
77851     try {
77852       delete arg1;
77853     } catch (std::out_of_range& e) {
77854       {
77855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77856       };
77857     } catch (std::exception& e) {
77858       {
77859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77860       };
77861     } catch (...) {
77862       {
77863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77864       };
77865     }
77866   }
77867 }
77868
77869
77870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
77871   void * jresult ;
77872   Dali::BaseHandle arg1 ;
77873   Dali::BaseHandle *argp1 ;
77874   Dali::Toolkit::TextField result;
77875
77876   argp1 = (Dali::BaseHandle *)jarg1;
77877   if (!argp1) {
77878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77879     return 0;
77880   }
77881   arg1 = *argp1;
77882   {
77883     try {
77884       result = Dali::Toolkit::TextField::DownCast(arg1);
77885     } catch (std::out_of_range& e) {
77886       {
77887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77888       };
77889     } catch (std::exception& e) {
77890       {
77891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77892       };
77893     } catch (...) {
77894       {
77895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77896       };
77897     }
77898   }
77899   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
77900   return jresult;
77901 }
77902
77903
77904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
77905   void * jresult ;
77906   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77907   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
77908
77909   arg1 = (Dali::Toolkit::TextField *)jarg1;
77910   {
77911     try {
77912       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
77913     } catch (std::out_of_range& e) {
77914       {
77915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77916       };
77917     } catch (std::exception& e) {
77918       {
77919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77920       };
77921     } catch (...) {
77922       {
77923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77924       };
77925     }
77926   }
77927   jresult = (void *)result;
77928   return jresult;
77929 }
77930
77931
77932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
77933   void * jresult ;
77934   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77935   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
77936
77937   arg1 = (Dali::Toolkit::TextField *)jarg1;
77938   {
77939     try {
77940       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
77941     } catch (std::out_of_range& e) {
77942       {
77943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77944       };
77945     } catch (std::exception& e) {
77946       {
77947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77948       };
77949     } catch (...) {
77950       {
77951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77952       };
77953     }
77954   }
77955   jresult = (void *)result;
77956   return jresult;
77957 }
77958
77959
77960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
77961   void * jresult ;
77962   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
77963   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
77964
77965   arg1 = (Dali::Toolkit::TextField *)jarg1;
77966   {
77967     try {
77968       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
77969     } catch (std::out_of_range& e) {
77970       {
77971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77972       };
77973     } catch (std::exception& e) {
77974       {
77975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77976       };
77977     } catch (...) {
77978       {
77979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77980       };
77981     }
77982   }
77983   jresult = (void *)result;
77984   return jresult;
77985 }
77986
77987
77988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
77989   int jresult ;
77990   int result;
77991
77992   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
77993   jresult = (int)result;
77994   return jresult;
77995 }
77996
77997
77998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
77999   int jresult ;
78000   int result;
78001
78002   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78003   jresult = (int)result;
78004   return jresult;
78005 }
78006
78007
78008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78009   int jresult ;
78010   int result;
78011
78012   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78013   jresult = (int)result;
78014   return jresult;
78015 }
78016
78017
78018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78019   int jresult ;
78020   int result;
78021
78022   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78023   jresult = (int)result;
78024   return jresult;
78025 }
78026
78027
78028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78029   int jresult ;
78030   int result;
78031
78032   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78033   jresult = (int)result;
78034   return jresult;
78035 }
78036
78037
78038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78039   int jresult ;
78040   int result;
78041
78042   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78043   jresult = (int)result;
78044   return jresult;
78045 }
78046
78047
78048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78049   int jresult ;
78050   int result;
78051
78052   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78053   jresult = (int)result;
78054   return jresult;
78055 }
78056
78057
78058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78059   int jresult ;
78060   int result;
78061
78062   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78063   jresult = (int)result;
78064   return jresult;
78065 }
78066
78067
78068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78069   int jresult ;
78070   int result;
78071
78072   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78073   jresult = (int)result;
78074   return jresult;
78075 }
78076
78077
78078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
78079   int jresult ;
78080   int result;
78081
78082   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
78083   jresult = (int)result;
78084   return jresult;
78085 }
78086
78087
78088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
78089   int jresult ;
78090   int result;
78091
78092   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
78093   jresult = (int)result;
78094   return jresult;
78095 }
78096
78097
78098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
78099   int jresult ;
78100   int result;
78101
78102   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
78103   jresult = (int)result;
78104   return jresult;
78105 }
78106
78107
78108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
78109   int jresult ;
78110   int result;
78111
78112   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
78113   jresult = (int)result;
78114   return jresult;
78115 }
78116
78117
78118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
78119   int jresult ;
78120   int result;
78121
78122   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
78123   jresult = (int)result;
78124   return jresult;
78125 }
78126
78127
78128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78129   int jresult ;
78130   int result;
78131
78132   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78133   jresult = (int)result;
78134   return jresult;
78135 }
78136
78137
78138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78139   int jresult ;
78140   int result;
78141
78142   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78143   jresult = (int)result;
78144   return jresult;
78145 }
78146
78147
78148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78149   int jresult ;
78150   int result;
78151
78152   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78153   jresult = (int)result;
78154   return jresult;
78155 }
78156
78157
78158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78159   int jresult ;
78160   int result;
78161
78162   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78163   jresult = (int)result;
78164   return jresult;
78165 }
78166
78167
78168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78169   int jresult ;
78170   int result;
78171
78172   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78173   jresult = (int)result;
78174   return jresult;
78175 }
78176
78177
78178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78179   int jresult ;
78180   int result;
78181
78182   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78183   jresult = (int)result;
78184   return jresult;
78185 }
78186
78187
78188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78189   int jresult ;
78190   int result;
78191
78192   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78193   jresult = (int)result;
78194   return jresult;
78195 }
78196
78197
78198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78199   int jresult ;
78200   int result;
78201
78202   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78203   jresult = (int)result;
78204   return jresult;
78205 }
78206
78207
78208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78209   int jresult ;
78210   int result;
78211
78212   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78213   jresult = (int)result;
78214   return jresult;
78215 }
78216
78217
78218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78219   int jresult ;
78220   int result;
78221
78222   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78223   jresult = (int)result;
78224   return jresult;
78225 }
78226
78227
78228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78229   void * jresult ;
78230   Dali::Toolkit::TextLabel::Property *result = 0 ;
78231
78232   {
78233     try {
78234       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78235     } catch (std::out_of_range& e) {
78236       {
78237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78238       };
78239     } catch (std::exception& e) {
78240       {
78241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78242       };
78243     } catch (...) {
78244       {
78245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78246       };
78247     }
78248   }
78249   jresult = (void *)result;
78250   return jresult;
78251 }
78252
78253
78254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78255   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78256
78257   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78258   {
78259     try {
78260       delete arg1;
78261     } catch (std::out_of_range& e) {
78262       {
78263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78264       };
78265     } catch (std::exception& e) {
78266       {
78267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78268       };
78269     } catch (...) {
78270       {
78271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78272       };
78273     }
78274   }
78275 }
78276
78277
78278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78279   void * jresult ;
78280   Dali::Toolkit::TextLabel result;
78281
78282   {
78283     try {
78284       result = Dali::Toolkit::TextLabel::New();
78285     } catch (std::out_of_range& e) {
78286       {
78287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78288       };
78289     } catch (std::exception& e) {
78290       {
78291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78292       };
78293     } catch (...) {
78294       {
78295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78296       };
78297     }
78298   }
78299   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78300   return jresult;
78301 }
78302
78303
78304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78305   void * jresult ;
78306   std::string *arg1 = 0 ;
78307   Dali::Toolkit::TextLabel result;
78308
78309   if (!jarg1) {
78310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78311     return 0;
78312   }
78313   std::string arg1_str(jarg1);
78314   arg1 = &arg1_str;
78315   {
78316     try {
78317       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78318     } catch (std::out_of_range& e) {
78319       {
78320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78321       };
78322     } catch (std::exception& e) {
78323       {
78324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78325       };
78326     } catch (...) {
78327       {
78328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78329       };
78330     }
78331   }
78332   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78333
78334   //argout typemap for const std::string&
78335
78336   return jresult;
78337 }
78338
78339
78340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78341   void * jresult ;
78342   Dali::Toolkit::TextLabel *result = 0 ;
78343
78344   {
78345     try {
78346       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78347     } catch (std::out_of_range& e) {
78348       {
78349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78350       };
78351     } catch (std::exception& e) {
78352       {
78353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78354       };
78355     } catch (...) {
78356       {
78357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78358       };
78359     }
78360   }
78361   jresult = (void *)result;
78362   return jresult;
78363 }
78364
78365
78366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78367   void * jresult ;
78368   Dali::Toolkit::TextLabel *arg1 = 0 ;
78369   Dali::Toolkit::TextLabel *result = 0 ;
78370
78371   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78372   if (!arg1) {
78373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78374     return 0;
78375   }
78376   {
78377     try {
78378       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78379     } catch (std::out_of_range& e) {
78380       {
78381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78382       };
78383     } catch (std::exception& e) {
78384       {
78385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78386       };
78387     } catch (...) {
78388       {
78389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78390       };
78391     }
78392   }
78393   jresult = (void *)result;
78394   return jresult;
78395 }
78396
78397
78398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78399   void * jresult ;
78400   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78401   Dali::Toolkit::TextLabel *arg2 = 0 ;
78402   Dali::Toolkit::TextLabel *result = 0 ;
78403
78404   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78405   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78406   if (!arg2) {
78407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78408     return 0;
78409   }
78410   {
78411     try {
78412       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78413     } catch (std::out_of_range& e) {
78414       {
78415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78416       };
78417     } catch (std::exception& e) {
78418       {
78419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78420       };
78421     } catch (...) {
78422       {
78423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78424       };
78425     }
78426   }
78427   jresult = (void *)result;
78428   return jresult;
78429 }
78430
78431
78432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78433   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78434
78435   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78436   {
78437     try {
78438       delete arg1;
78439     } catch (std::out_of_range& e) {
78440       {
78441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78442       };
78443     } catch (std::exception& e) {
78444       {
78445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78446       };
78447     } catch (...) {
78448       {
78449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78450       };
78451     }
78452   }
78453 }
78454
78455
78456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78457   void * jresult ;
78458   Dali::BaseHandle arg1 ;
78459   Dali::BaseHandle *argp1 ;
78460   Dali::Toolkit::TextLabel result;
78461
78462   argp1 = (Dali::BaseHandle *)jarg1;
78463   if (!argp1) {
78464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78465     return 0;
78466   }
78467   arg1 = *argp1;
78468   {
78469     try {
78470       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78471     } catch (std::out_of_range& e) {
78472       {
78473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78474       };
78475     } catch (std::exception& e) {
78476       {
78477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78478       };
78479     } catch (...) {
78480       {
78481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78482       };
78483     }
78484   }
78485   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78486   return jresult;
78487 }
78488
78489
78490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78491   void * jresult ;
78492   Dali::Toolkit::AccessibilityManager *result = 0 ;
78493
78494   {
78495     try {
78496       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78497     } catch (std::out_of_range& e) {
78498       {
78499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78500       };
78501     } catch (std::exception& e) {
78502       {
78503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78504       };
78505     } catch (...) {
78506       {
78507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78508       };
78509     }
78510   }
78511   jresult = (void *)result;
78512   return jresult;
78513 }
78514
78515
78516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78517   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78518
78519   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78520   {
78521     try {
78522       delete arg1;
78523     } catch (std::out_of_range& e) {
78524       {
78525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78526       };
78527     } catch (std::exception& e) {
78528       {
78529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78530       };
78531     } catch (...) {
78532       {
78533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78534       };
78535     }
78536   }
78537 }
78538
78539
78540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78541   void * jresult ;
78542   Dali::Toolkit::AccessibilityManager result;
78543
78544   {
78545     try {
78546       result = Dali::Toolkit::AccessibilityManager::Get();
78547     } catch (std::out_of_range& e) {
78548       {
78549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78550       };
78551     } catch (std::exception& e) {
78552       {
78553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78554       };
78555     } catch (...) {
78556       {
78557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78558       };
78559     }
78560   }
78561   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78562   return jresult;
78563 }
78564
78565
78566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78567   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78568   Dali::Actor arg2 ;
78569   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78570   std::string *arg4 = 0 ;
78571   Dali::Actor *argp2 ;
78572
78573   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78574   argp2 = (Dali::Actor *)jarg2;
78575   if (!argp2) {
78576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78577     return ;
78578   }
78579   arg2 = *argp2;
78580   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78581   if (!jarg4) {
78582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78583     return ;
78584   }
78585   std::string arg4_str(jarg4);
78586   arg4 = &arg4_str;
78587   {
78588     try {
78589       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
78590     } catch (std::out_of_range& e) {
78591       {
78592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78593       };
78594     } catch (std::exception& e) {
78595       {
78596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78597       };
78598     } catch (...) {
78599       {
78600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78601       };
78602     }
78603   }
78604
78605   //argout typemap for const std::string&
78606
78607 }
78608
78609
78610 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
78611   char * jresult ;
78612   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78613   Dali::Actor arg2 ;
78614   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78615   Dali::Actor *argp2 ;
78616   std::string result;
78617
78618   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78619   argp2 = (Dali::Actor *)jarg2;
78620   if (!argp2) {
78621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78622     return 0;
78623   }
78624   arg2 = *argp2;
78625   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78626   {
78627     try {
78628       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
78629     } catch (std::out_of_range& e) {
78630       {
78631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78632       };
78633     } catch (std::exception& e) {
78634       {
78635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78636       };
78637     } catch (...) {
78638       {
78639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78640       };
78641     }
78642   }
78643   jresult = SWIG_csharp_string_callback((&result)->c_str());
78644   return jresult;
78645 }
78646
78647
78648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
78649   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78650   Dali::Actor arg2 ;
78651   unsigned int arg3 ;
78652   Dali::Actor *argp2 ;
78653
78654   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78655   argp2 = (Dali::Actor *)jarg2;
78656   if (!argp2) {
78657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78658     return ;
78659   }
78660   arg2 = *argp2;
78661   arg3 = (unsigned int)jarg3;
78662   {
78663     try {
78664       (arg1)->SetFocusOrder(arg2,arg3);
78665     } catch (std::out_of_range& e) {
78666       {
78667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78668       };
78669     } catch (std::exception& e) {
78670       {
78671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78672       };
78673     } catch (...) {
78674       {
78675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78676       };
78677     }
78678   }
78679 }
78680
78681
78682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
78683   unsigned int jresult ;
78684   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78685   Dali::Actor arg2 ;
78686   Dali::Actor *argp2 ;
78687   unsigned int result;
78688
78689   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78690   argp2 = (Dali::Actor *)jarg2;
78691   if (!argp2) {
78692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78693     return 0;
78694   }
78695   arg2 = *argp2;
78696   {
78697     try {
78698       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
78699     } catch (std::out_of_range& e) {
78700       {
78701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78702       };
78703     } catch (std::exception& e) {
78704       {
78705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78706       };
78707     } catch (...) {
78708       {
78709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78710       };
78711     }
78712   }
78713   jresult = result;
78714   return jresult;
78715 }
78716
78717
78718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
78719   unsigned int jresult ;
78720   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78721   unsigned int result;
78722
78723   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78724   {
78725     try {
78726       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
78727     } catch (std::out_of_range& e) {
78728       {
78729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78730       };
78731     } catch (std::exception& e) {
78732       {
78733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78734       };
78735     } catch (...) {
78736       {
78737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78738       };
78739     }
78740   }
78741   jresult = result;
78742   return jresult;
78743 }
78744
78745
78746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
78747   void * jresult ;
78748   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78749   unsigned int arg2 ;
78750   Dali::Actor result;
78751
78752   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78753   arg2 = (unsigned int)jarg2;
78754   {
78755     try {
78756       result = (arg1)->GetActorByFocusOrder(arg2);
78757     } catch (std::out_of_range& e) {
78758       {
78759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78760       };
78761     } catch (std::exception& e) {
78762       {
78763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78764       };
78765     } catch (...) {
78766       {
78767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78768       };
78769     }
78770   }
78771   jresult = new Dali::Actor((const Dali::Actor &)result);
78772   return jresult;
78773 }
78774
78775
78776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
78777   unsigned int jresult ;
78778   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78779   Dali::Actor arg2 ;
78780   Dali::Actor *argp2 ;
78781   bool result;
78782
78783   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78784   argp2 = (Dali::Actor *)jarg2;
78785   if (!argp2) {
78786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78787     return 0;
78788   }
78789   arg2 = *argp2;
78790   {
78791     try {
78792       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
78793     } catch (std::out_of_range& e) {
78794       {
78795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78796       };
78797     } catch (std::exception& e) {
78798       {
78799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78800       };
78801     } catch (...) {
78802       {
78803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78804       };
78805     }
78806   }
78807   jresult = result;
78808   return jresult;
78809 }
78810
78811
78812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
78813   void * jresult ;
78814   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78815   Dali::Actor result;
78816
78817   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78818   {
78819     try {
78820       result = (arg1)->GetCurrentFocusActor();
78821     } catch (std::out_of_range& e) {
78822       {
78823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78824       };
78825     } catch (std::exception& e) {
78826       {
78827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78828       };
78829     } catch (...) {
78830       {
78831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78832       };
78833     }
78834   }
78835   jresult = new Dali::Actor((const Dali::Actor &)result);
78836   return jresult;
78837 }
78838
78839
78840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
78841   void * jresult ;
78842   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78843   Dali::Actor result;
78844
78845   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78846   {
78847     try {
78848       result = (arg1)->GetCurrentFocusGroup();
78849     } catch (std::out_of_range& e) {
78850       {
78851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78852       };
78853     } catch (std::exception& e) {
78854       {
78855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78856       };
78857     } catch (...) {
78858       {
78859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78860       };
78861     }
78862   }
78863   jresult = new Dali::Actor((const Dali::Actor &)result);
78864   return jresult;
78865 }
78866
78867
78868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
78869   unsigned int jresult ;
78870   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78871   unsigned int result;
78872
78873   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78874   {
78875     try {
78876       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
78877     } catch (std::out_of_range& e) {
78878       {
78879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78880       };
78881     } catch (std::exception& e) {
78882       {
78883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78884       };
78885     } catch (...) {
78886       {
78887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78888       };
78889     }
78890   }
78891   jresult = result;
78892   return jresult;
78893 }
78894
78895
78896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
78897   unsigned int jresult ;
78898   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78899   bool result;
78900
78901   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78902   {
78903     try {
78904       result = (bool)(arg1)->MoveFocusForward();
78905     } catch (std::out_of_range& e) {
78906       {
78907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78908       };
78909     } catch (std::exception& e) {
78910       {
78911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78912       };
78913     } catch (...) {
78914       {
78915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78916       };
78917     }
78918   }
78919   jresult = result;
78920   return jresult;
78921 }
78922
78923
78924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
78925   unsigned int jresult ;
78926   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78927   bool result;
78928
78929   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78930   {
78931     try {
78932       result = (bool)(arg1)->MoveFocusBackward();
78933     } catch (std::out_of_range& e) {
78934       {
78935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78936       };
78937     } catch (std::exception& e) {
78938       {
78939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78940       };
78941     } catch (...) {
78942       {
78943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78944       };
78945     }
78946   }
78947   jresult = result;
78948   return jresult;
78949 }
78950
78951
78952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
78953   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78954
78955   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78956   {
78957     try {
78958       (arg1)->ClearFocus();
78959     } catch (std::out_of_range& e) {
78960       {
78961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78962       };
78963     } catch (std::exception& e) {
78964       {
78965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78966       };
78967     } catch (...) {
78968       {
78969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78970       };
78971     }
78972   }
78973 }
78974
78975
78976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
78977   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78978
78979   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78980   {
78981     try {
78982       (arg1)->Reset();
78983     } catch (std::out_of_range& e) {
78984       {
78985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78986       };
78987     } catch (std::exception& e) {
78988       {
78989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78990       };
78991     } catch (...) {
78992       {
78993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78994       };
78995     }
78996   }
78997 }
78998
78999
79000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79001   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79002   Dali::Actor arg2 ;
79003   bool arg3 ;
79004   Dali::Actor *argp2 ;
79005
79006   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79007   argp2 = (Dali::Actor *)jarg2;
79008   if (!argp2) {
79009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79010     return ;
79011   }
79012   arg2 = *argp2;
79013   arg3 = jarg3 ? true : false;
79014   {
79015     try {
79016       (arg1)->SetFocusGroup(arg2,arg3);
79017     } catch (std::out_of_range& e) {
79018       {
79019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79020       };
79021     } catch (std::exception& e) {
79022       {
79023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79024       };
79025     } catch (...) {
79026       {
79027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79028       };
79029     }
79030   }
79031 }
79032
79033
79034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79035   unsigned int jresult ;
79036   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79037   Dali::Actor arg2 ;
79038   Dali::Actor *argp2 ;
79039   bool result;
79040
79041   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79042   argp2 = (Dali::Actor *)jarg2;
79043   if (!argp2) {
79044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79045     return 0;
79046   }
79047   arg2 = *argp2;
79048   {
79049     try {
79050       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79051     } catch (std::out_of_range& e) {
79052       {
79053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79054       };
79055     } catch (std::exception& e) {
79056       {
79057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79058       };
79059     } catch (...) {
79060       {
79061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79062       };
79063     }
79064   }
79065   jresult = result;
79066   return jresult;
79067 }
79068
79069
79070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79071   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79072   bool arg2 ;
79073
79074   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79075   arg2 = jarg2 ? true : false;
79076   {
79077     try {
79078       (arg1)->SetGroupMode(arg2);
79079     } catch (std::out_of_range& e) {
79080       {
79081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79082       };
79083     } catch (std::exception& e) {
79084       {
79085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79086       };
79087     } catch (...) {
79088       {
79089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79090       };
79091     }
79092   }
79093 }
79094
79095
79096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79097   unsigned int jresult ;
79098   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79099   bool result;
79100
79101   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79102   {
79103     try {
79104       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79105     } catch (std::out_of_range& e) {
79106       {
79107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79108       };
79109     } catch (std::exception& e) {
79110       {
79111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79112       };
79113     } catch (...) {
79114       {
79115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79116       };
79117     }
79118   }
79119   jresult = result;
79120   return jresult;
79121 }
79122
79123
79124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79125   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79126   bool arg2 ;
79127
79128   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79129   arg2 = jarg2 ? true : false;
79130   {
79131     try {
79132       (arg1)->SetWrapMode(arg2);
79133     } catch (std::out_of_range& e) {
79134       {
79135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79136       };
79137     } catch (std::exception& e) {
79138       {
79139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79140       };
79141     } catch (...) {
79142       {
79143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79144       };
79145     }
79146   }
79147 }
79148
79149
79150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79151   unsigned int jresult ;
79152   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79153   bool result;
79154
79155   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79156   {
79157     try {
79158       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79159     } catch (std::out_of_range& e) {
79160       {
79161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79162       };
79163     } catch (std::exception& e) {
79164       {
79165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79166       };
79167     } catch (...) {
79168       {
79169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79170       };
79171     }
79172   }
79173   jresult = result;
79174   return jresult;
79175 }
79176
79177
79178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79179   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79180   Dali::Actor arg2 ;
79181   Dali::Actor *argp2 ;
79182
79183   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79184   argp2 = (Dali::Actor *)jarg2;
79185   if (!argp2) {
79186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79187     return ;
79188   }
79189   arg2 = *argp2;
79190   {
79191     try {
79192       (arg1)->SetFocusIndicatorActor(arg2);
79193     } catch (std::out_of_range& e) {
79194       {
79195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79196       };
79197     } catch (std::exception& e) {
79198       {
79199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79200       };
79201     } catch (...) {
79202       {
79203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79204       };
79205     }
79206   }
79207 }
79208
79209
79210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79211   void * jresult ;
79212   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79213   Dali::Actor result;
79214
79215   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79216   {
79217     try {
79218       result = (arg1)->GetFocusIndicatorActor();
79219     } catch (std::out_of_range& e) {
79220       {
79221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79222       };
79223     } catch (std::exception& e) {
79224       {
79225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79226       };
79227     } catch (...) {
79228       {
79229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79230       };
79231     }
79232   }
79233   jresult = new Dali::Actor((const Dali::Actor &)result);
79234   return jresult;
79235 }
79236
79237
79238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79239   void * jresult ;
79240   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79241   Dali::Actor arg2 ;
79242   Dali::Actor *argp2 ;
79243   Dali::Actor result;
79244
79245   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79246   argp2 = (Dali::Actor *)jarg2;
79247   if (!argp2) {
79248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79249     return 0;
79250   }
79251   arg2 = *argp2;
79252   {
79253     try {
79254       result = (arg1)->GetFocusGroup(arg2);
79255     } catch (std::out_of_range& e) {
79256       {
79257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79258       };
79259     } catch (std::exception& e) {
79260       {
79261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79262       };
79263     } catch (...) {
79264       {
79265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79266       };
79267     }
79268   }
79269   jresult = new Dali::Actor((const Dali::Actor &)result);
79270   return jresult;
79271 }
79272
79273
79274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79275   void * jresult ;
79276   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79277   Dali::Vector2 result;
79278
79279   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79280   {
79281     try {
79282       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79283     } catch (std::out_of_range& e) {
79284       {
79285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79286       };
79287     } catch (std::exception& e) {
79288       {
79289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79290       };
79291     } catch (...) {
79292       {
79293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79294       };
79295     }
79296   }
79297   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79298   return jresult;
79299 }
79300
79301
79302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79303   void * jresult ;
79304   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79305   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79306
79307   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79308   {
79309     try {
79310       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79311     } catch (std::out_of_range& e) {
79312       {
79313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79314       };
79315     } catch (std::exception& e) {
79316       {
79317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79318       };
79319     } catch (...) {
79320       {
79321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79322       };
79323     }
79324   }
79325   jresult = (void *)result;
79326   return jresult;
79327 }
79328
79329
79330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79331   void * jresult ;
79332   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79333   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79334
79335   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79336   {
79337     try {
79338       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79339     } catch (std::out_of_range& e) {
79340       {
79341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79342       };
79343     } catch (std::exception& e) {
79344       {
79345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79346       };
79347     } catch (...) {
79348       {
79349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79350       };
79351     }
79352   }
79353   jresult = (void *)result;
79354   return jresult;
79355 }
79356
79357
79358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79359   void * jresult ;
79360   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79361   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79362
79363   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79364   {
79365     try {
79366       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79367     } catch (std::out_of_range& e) {
79368       {
79369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79370       };
79371     } catch (std::exception& e) {
79372       {
79373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79374       };
79375     } catch (...) {
79376       {
79377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79378       };
79379     }
79380   }
79381   jresult = (void *)result;
79382   return jresult;
79383 }
79384
79385
79386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79387   void * jresult ;
79388   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79389   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79390
79391   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79392   {
79393     try {
79394       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79395     } catch (std::out_of_range& e) {
79396       {
79397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79398       };
79399     } catch (std::exception& e) {
79400       {
79401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79402       };
79403     } catch (...) {
79404       {
79405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79406       };
79407     }
79408   }
79409   jresult = (void *)result;
79410   return jresult;
79411 }
79412
79413
79414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79415   void * jresult ;
79416   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79417   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79418
79419   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79420   {
79421     try {
79422       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79423     } catch (std::out_of_range& e) {
79424       {
79425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79426       };
79427     } catch (std::exception& e) {
79428       {
79429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79430       };
79431     } catch (...) {
79432       {
79433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79434       };
79435     }
79436   }
79437   jresult = (void *)result;
79438   return jresult;
79439 }
79440
79441
79442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79443   void * jresult ;
79444   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79445   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79446
79447   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79448   {
79449     try {
79450       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79451     } catch (std::out_of_range& e) {
79452       {
79453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79454       };
79455     } catch (std::exception& e) {
79456       {
79457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79458       };
79459     } catch (...) {
79460       {
79461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79462       };
79463     }
79464   }
79465   jresult = (void *)result;
79466   return jresult;
79467 }
79468
79469
79470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79471   void * jresult ;
79472   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79473   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79474
79475   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79476   {
79477     try {
79478       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79479     } catch (std::out_of_range& e) {
79480       {
79481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79482       };
79483     } catch (std::exception& e) {
79484       {
79485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79486       };
79487     } catch (...) {
79488       {
79489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79490       };
79491     }
79492   }
79493   jresult = (void *)result;
79494   return jresult;
79495 }
79496
79497
79498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
79499   void * jresult ;
79500   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79501   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79502
79503   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79504   {
79505     try {
79506       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
79507     } catch (std::out_of_range& e) {
79508       {
79509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79510       };
79511     } catch (std::exception& e) {
79512       {
79513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79514       };
79515     } catch (...) {
79516       {
79517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79518       };
79519     }
79520   }
79521   jresult = (void *)result;
79522   return jresult;
79523 }
79524
79525
79526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
79527   void * jresult ;
79528   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79529   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79530
79531   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79532   {
79533     try {
79534       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
79535     } catch (std::out_of_range& e) {
79536       {
79537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79538       };
79539     } catch (std::exception& e) {
79540       {
79541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79542       };
79543     } catch (...) {
79544       {
79545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79546       };
79547     }
79548   }
79549   jresult = (void *)result;
79550   return jresult;
79551 }
79552
79553
79554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
79555   void * jresult ;
79556   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79557   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79558
79559   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79560   {
79561     try {
79562       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
79563     } catch (std::out_of_range& e) {
79564       {
79565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79566       };
79567     } catch (std::exception& e) {
79568       {
79569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79570       };
79571     } catch (...) {
79572       {
79573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79574       };
79575     }
79576   }
79577   jresult = (void *)result;
79578   return jresult;
79579 }
79580
79581
79582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
79583   void * jresult ;
79584   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79585   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79586
79587   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79588   {
79589     try {
79590       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
79591     } catch (std::out_of_range& e) {
79592       {
79593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79594       };
79595     } catch (std::exception& e) {
79596       {
79597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79598       };
79599     } catch (...) {
79600       {
79601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79602       };
79603     }
79604   }
79605   jresult = (void *)result;
79606   return jresult;
79607 }
79608
79609
79610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
79611   void * jresult ;
79612   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79613   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79614
79615   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79616   {
79617     try {
79618       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
79619     } catch (std::out_of_range& e) {
79620       {
79621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79622       };
79623     } catch (std::exception& e) {
79624       {
79625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79626       };
79627     } catch (...) {
79628       {
79629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79630       };
79631     }
79632   }
79633   jresult = (void *)result;
79634   return jresult;
79635 }
79636
79637
79638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
79639   void * jresult ;
79640   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79641   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79642
79643   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79644   {
79645     try {
79646       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
79647     } catch (std::out_of_range& e) {
79648       {
79649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79650       };
79651     } catch (std::exception& e) {
79652       {
79653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79654       };
79655     } catch (...) {
79656       {
79657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79658       };
79659     }
79660   }
79661   jresult = (void *)result;
79662   return jresult;
79663 }
79664
79665
79666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
79667   void * jresult ;
79668   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79669   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79670
79671   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79672   {
79673     try {
79674       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
79675     } catch (std::out_of_range& e) {
79676       {
79677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79678       };
79679     } catch (std::exception& e) {
79680       {
79681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79682       };
79683     } catch (...) {
79684       {
79685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79686       };
79687     }
79688   }
79689   jresult = (void *)result;
79690   return jresult;
79691 }
79692
79693
79694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
79695   void * jresult ;
79696   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79697   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79698
79699   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79700   {
79701     try {
79702       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
79703     } catch (std::out_of_range& e) {
79704       {
79705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79706       };
79707     } catch (std::exception& e) {
79708       {
79709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79710       };
79711     } catch (...) {
79712       {
79713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79714       };
79715     }
79716   }
79717   jresult = (void *)result;
79718   return jresult;
79719 }
79720
79721
79722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
79723   void * jresult ;
79724   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79725   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79726
79727   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79728   {
79729     try {
79730       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
79731     } catch (std::out_of_range& e) {
79732       {
79733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79734       };
79735     } catch (std::exception& e) {
79736       {
79737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79738       };
79739     } catch (...) {
79740       {
79741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79742       };
79743     }
79744   }
79745   jresult = (void *)result;
79746   return jresult;
79747 }
79748
79749
79750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
79751   void * jresult ;
79752   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79753   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79754
79755   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79756   {
79757     try {
79758       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
79759     } catch (std::out_of_range& e) {
79760       {
79761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79762       };
79763     } catch (std::exception& e) {
79764       {
79765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79766       };
79767     } catch (...) {
79768       {
79769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79770       };
79771     }
79772   }
79773   jresult = (void *)result;
79774   return jresult;
79775 }
79776
79777
79778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
79779   void * jresult ;
79780   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79781   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79782
79783   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79784   {
79785     try {
79786       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
79787     } catch (std::out_of_range& e) {
79788       {
79789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79790       };
79791     } catch (std::exception& e) {
79792       {
79793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79794       };
79795     } catch (...) {
79796       {
79797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79798       };
79799     }
79800   }
79801   jresult = (void *)result;
79802   return jresult;
79803 }
79804
79805
79806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
79807   void * jresult ;
79808   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79809   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79810
79811   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79812   {
79813     try {
79814       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
79815     } catch (std::out_of_range& e) {
79816       {
79817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79818       };
79819     } catch (std::exception& e) {
79820       {
79821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79822       };
79823     } catch (...) {
79824       {
79825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79826       };
79827     }
79828   }
79829   jresult = (void *)result;
79830   return jresult;
79831 }
79832
79833
79834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
79835   void * jresult ;
79836   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79837   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79838
79839   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79840   {
79841     try {
79842       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
79843     } catch (std::out_of_range& e) {
79844       {
79845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79846       };
79847     } catch (std::exception& e) {
79848       {
79849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79850       };
79851     } catch (...) {
79852       {
79853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79854       };
79855     }
79856   }
79857   jresult = (void *)result;
79858   return jresult;
79859 }
79860
79861
79862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
79863   void * jresult ;
79864   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79865   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79866
79867   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79868   {
79869     try {
79870       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
79871     } catch (std::out_of_range& e) {
79872       {
79873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79874       };
79875     } catch (std::exception& e) {
79876       {
79877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79878       };
79879     } catch (...) {
79880       {
79881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79882       };
79883     }
79884   }
79885   jresult = (void *)result;
79886   return jresult;
79887 }
79888
79889
79890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
79891   void * jresult ;
79892   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79893   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79894
79895   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79896   {
79897     try {
79898       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
79899     } catch (std::out_of_range& e) {
79900       {
79901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79902       };
79903     } catch (std::exception& e) {
79904       {
79905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79906       };
79907     } catch (...) {
79908       {
79909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79910       };
79911     }
79912   }
79913   jresult = (void *)result;
79914   return jresult;
79915 }
79916
79917
79918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
79919   void * jresult ;
79920   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79921   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79922
79923   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79924   {
79925     try {
79926       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
79927     } catch (std::out_of_range& e) {
79928       {
79929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79930       };
79931     } catch (std::exception& e) {
79932       {
79933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79934       };
79935     } catch (...) {
79936       {
79937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79938       };
79939     }
79940   }
79941   jresult = (void *)result;
79942   return jresult;
79943 }
79944
79945
79946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
79947   void * jresult ;
79948   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79949   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79950
79951   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79952   {
79953     try {
79954       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
79955     } catch (std::out_of_range& e) {
79956       {
79957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79958       };
79959     } catch (std::exception& e) {
79960       {
79961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79962       };
79963     } catch (...) {
79964       {
79965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79966       };
79967     }
79968   }
79969   jresult = (void *)result;
79970   return jresult;
79971 }
79972
79973
79974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
79975   void * jresult ;
79976   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79977   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79978
79979   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79980   {
79981     try {
79982       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
79983     } catch (std::out_of_range& e) {
79984       {
79985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79986       };
79987     } catch (std::exception& e) {
79988       {
79989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79990       };
79991     } catch (...) {
79992       {
79993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79994       };
79995     }
79996   }
79997   jresult = (void *)result;
79998   return jresult;
79999 }
80000
80001
80002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80003   void * jresult ;
80004   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80005   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80006
80007   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80008   {
80009     try {
80010       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80011     } catch (std::out_of_range& e) {
80012       {
80013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80014       };
80015     } catch (std::exception& e) {
80016       {
80017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80018       };
80019     } catch (...) {
80020       {
80021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80022       };
80023     }
80024   }
80025   jresult = (void *)result;
80026   return jresult;
80027 }
80028
80029
80030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
80031   void * jresult ;
80032   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80033   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80034
80035   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80036   {
80037     try {
80038       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
80039     } catch (std::out_of_range& e) {
80040       {
80041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80042       };
80043     } catch (std::exception& e) {
80044       {
80045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80046       };
80047     } catch (...) {
80048       {
80049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80050       };
80051     }
80052   }
80053   jresult = (void *)result;
80054   return jresult;
80055 }
80056
80057
80058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80059   void * jresult ;
80060   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80061   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80062
80063   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80064   {
80065     try {
80066       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80067     } catch (std::out_of_range& e) {
80068       {
80069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80070       };
80071     } catch (std::exception& e) {
80072       {
80073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80074       };
80075     } catch (...) {
80076       {
80077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80078       };
80079     }
80080   }
80081   jresult = (void *)result;
80082   return jresult;
80083 }
80084
80085
80086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80087   void * jresult ;
80088   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80089   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80090
80091   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80092   {
80093     try {
80094       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80095     } catch (std::out_of_range& e) {
80096       {
80097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80098       };
80099     } catch (std::exception& e) {
80100       {
80101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80102       };
80103     } catch (...) {
80104       {
80105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80106       };
80107     }
80108   }
80109   jresult = (void *)result;
80110   return jresult;
80111 }
80112
80113
80114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80115   void * jresult ;
80116   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80117   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80118
80119   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80120   {
80121     try {
80122       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80123     } catch (std::out_of_range& e) {
80124       {
80125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80126       };
80127     } catch (std::exception& e) {
80128       {
80129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80130       };
80131     } catch (...) {
80132       {
80133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80134       };
80135     }
80136   }
80137   jresult = (void *)result;
80138   return jresult;
80139 }
80140
80141
80142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80143   void * jresult ;
80144   Dali::Toolkit::StyleManager *result = 0 ;
80145
80146   {
80147     try {
80148       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80149     } catch (std::out_of_range& e) {
80150       {
80151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80152       };
80153     } catch (std::exception& e) {
80154       {
80155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80156       };
80157     } catch (...) {
80158       {
80159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80160       };
80161     }
80162   }
80163   jresult = (void *)result;
80164   return jresult;
80165 }
80166
80167
80168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80169   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80170
80171   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80172   {
80173     try {
80174       delete arg1;
80175     } catch (std::out_of_range& e) {
80176       {
80177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80178       };
80179     } catch (std::exception& e) {
80180       {
80181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80182       };
80183     } catch (...) {
80184       {
80185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80186       };
80187     }
80188   }
80189 }
80190
80191
80192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80193   void * jresult ;
80194   Dali::Toolkit::StyleManager result;
80195
80196   {
80197     try {
80198       result = Dali::Toolkit::StyleManager::Get();
80199     } catch (std::out_of_range& e) {
80200       {
80201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80202       };
80203     } catch (std::exception& e) {
80204       {
80205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80206       };
80207     } catch (...) {
80208       {
80209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80210       };
80211     }
80212   }
80213   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80214   return jresult;
80215 }
80216
80217
80218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80219   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80220   std::string *arg2 = 0 ;
80221
80222   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80223   if (!jarg2) {
80224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80225     return ;
80226   }
80227   std::string arg2_str(jarg2);
80228   arg2 = &arg2_str;
80229   {
80230     try {
80231       (arg1)->ApplyTheme((std::string const &)*arg2);
80232     } catch (std::out_of_range& e) {
80233       {
80234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80235       };
80236     } catch (std::exception& e) {
80237       {
80238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80239       };
80240     } catch (...) {
80241       {
80242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80243       };
80244     }
80245   }
80246
80247   //argout typemap for const std::string&
80248
80249 }
80250
80251
80252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80253   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80254
80255   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80256   {
80257     try {
80258       (arg1)->ApplyDefaultTheme();
80259     } catch (std::out_of_range& e) {
80260       {
80261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80262       };
80263     } catch (std::exception& e) {
80264       {
80265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80266       };
80267     } catch (...) {
80268       {
80269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80270       };
80271     }
80272   }
80273 }
80274
80275
80276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80277   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80278   std::string *arg2 = 0 ;
80279   Dali::Property::Value *arg3 = 0 ;
80280
80281   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80282   if (!jarg2) {
80283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80284     return ;
80285   }
80286   std::string arg2_str(jarg2);
80287   arg2 = &arg2_str;
80288   arg3 = (Dali::Property::Value *)jarg3;
80289   if (!arg3) {
80290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80291     return ;
80292   }
80293   {
80294     try {
80295       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80296     } catch (std::out_of_range& e) {
80297       {
80298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80299       };
80300     } catch (std::exception& e) {
80301       {
80302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80303       };
80304     } catch (...) {
80305       {
80306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80307       };
80308     }
80309   }
80310
80311   //argout typemap for const std::string&
80312
80313 }
80314
80315
80316 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80317   unsigned int jresult ;
80318   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80319   std::string *arg2 = 0 ;
80320   Dali::Property::Value *arg3 = 0 ;
80321   bool result;
80322
80323   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80324   if (!jarg2) {
80325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80326     return 0;
80327   }
80328   std::string arg2_str(jarg2);
80329   arg2 = &arg2_str;
80330   arg3 = (Dali::Property::Value *)jarg3;
80331   if (!arg3) {
80332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80333     return 0;
80334   }
80335   {
80336     try {
80337       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80338     } catch (std::out_of_range& e) {
80339       {
80340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80341       };
80342     } catch (std::exception& e) {
80343       {
80344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80345       };
80346     } catch (...) {
80347       {
80348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80349       };
80350     }
80351   }
80352   jresult = result;
80353
80354   //argout typemap for const std::string&
80355
80356   return jresult;
80357 }
80358
80359
80360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80361   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80362   Dali::Toolkit::Control arg2 ;
80363   std::string *arg3 = 0 ;
80364   std::string *arg4 = 0 ;
80365   Dali::Toolkit::Control *argp2 ;
80366
80367   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80368   argp2 = (Dali::Toolkit::Control *)jarg2;
80369   if (!argp2) {
80370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80371     return ;
80372   }
80373   arg2 = *argp2;
80374   if (!jarg3) {
80375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80376     return ;
80377   }
80378   std::string arg3_str(jarg3);
80379   arg3 = &arg3_str;
80380   if (!jarg4) {
80381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80382     return ;
80383   }
80384   std::string arg4_str(jarg4);
80385   arg4 = &arg4_str;
80386   {
80387     try {
80388       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80389     } catch (std::out_of_range& e) {
80390       {
80391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80392       };
80393     } catch (std::exception& e) {
80394       {
80395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80396       };
80397     } catch (...) {
80398       {
80399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80400       };
80401     }
80402   }
80403
80404   //argout typemap for const std::string&
80405
80406
80407   //argout typemap for const std::string&
80408
80409 }
80410
80411
80412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
80413   void * jresult ;
80414   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80415   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
80416
80417   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80418   {
80419     try {
80420       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
80421     } catch (std::out_of_range& e) {
80422       {
80423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80424       };
80425     } catch (std::exception& e) {
80426       {
80427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80428       };
80429     } catch (...) {
80430       {
80431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80432       };
80433     }
80434   }
80435   jresult = (void *)result;
80436   return jresult;
80437 }
80438
80439
80440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
80441   int jresult ;
80442   int result;
80443
80444   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
80445   jresult = (int)result;
80446   return jresult;
80447 }
80448
80449
80450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
80451   int jresult ;
80452   int result;
80453
80454   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
80455   jresult = (int)result;
80456   return jresult;
80457 }
80458
80459
80460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
80461   int jresult ;
80462   int result;
80463
80464   result = (int)Dali::Toolkit::Slider::Property::VALUE;
80465   jresult = (int)result;
80466   return jresult;
80467 }
80468
80469
80470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
80471   int jresult ;
80472   int result;
80473
80474   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
80475   jresult = (int)result;
80476   return jresult;
80477 }
80478
80479
80480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
80481   int jresult ;
80482   int result;
80483
80484   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
80485   jresult = (int)result;
80486   return jresult;
80487 }
80488
80489
80490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
80491   int jresult ;
80492   int result;
80493
80494   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
80495   jresult = (int)result;
80496   return jresult;
80497 }
80498
80499
80500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
80501   int jresult ;
80502   int result;
80503
80504   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
80505   jresult = (int)result;
80506   return jresult;
80507 }
80508
80509
80510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
80511   int jresult ;
80512   int result;
80513
80514   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
80515   jresult = (int)result;
80516   return jresult;
80517 }
80518
80519
80520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
80521   int jresult ;
80522   int result;
80523
80524   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
80525   jresult = (int)result;
80526   return jresult;
80527 }
80528
80529
80530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
80531   int jresult ;
80532   int result;
80533
80534   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
80535   jresult = (int)result;
80536   return jresult;
80537 }
80538
80539
80540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
80541   int jresult ;
80542   int result;
80543
80544   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
80545   jresult = (int)result;
80546   return jresult;
80547 }
80548
80549
80550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
80551   int jresult ;
80552   int result;
80553
80554   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
80555   jresult = (int)result;
80556   return jresult;
80557 }
80558
80559
80560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
80561   int jresult ;
80562   int result;
80563
80564   result = (int)Dali::Toolkit::Slider::Property::MARKS;
80565   jresult = (int)result;
80566   return jresult;
80567 }
80568
80569
80570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
80571   int jresult ;
80572   int result;
80573
80574   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
80575   jresult = (int)result;
80576   return jresult;
80577 }
80578
80579
80580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
80581   int jresult ;
80582   int result;
80583
80584   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
80585   jresult = (int)result;
80586   return jresult;
80587 }
80588
80589
80590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
80591   void * jresult ;
80592   Dali::Toolkit::Slider::Property *result = 0 ;
80593
80594   {
80595     try {
80596       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
80597     } catch (std::out_of_range& e) {
80598       {
80599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80600       };
80601     } catch (std::exception& e) {
80602       {
80603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80604       };
80605     } catch (...) {
80606       {
80607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80608       };
80609     }
80610   }
80611   jresult = (void *)result;
80612   return jresult;
80613 }
80614
80615
80616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
80617   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
80618
80619   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
80620   {
80621     try {
80622       delete arg1;
80623     } catch (std::out_of_range& e) {
80624       {
80625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80626       };
80627     } catch (std::exception& e) {
80628       {
80629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80630       };
80631     } catch (...) {
80632       {
80633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80634       };
80635     }
80636   }
80637 }
80638
80639
80640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
80641   void * jresult ;
80642   Dali::Toolkit::Slider result;
80643
80644   {
80645     try {
80646       result = Dali::Toolkit::Slider::New();
80647     } catch (std::out_of_range& e) {
80648       {
80649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80650       };
80651     } catch (std::exception& e) {
80652       {
80653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80654       };
80655     } catch (...) {
80656       {
80657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80658       };
80659     }
80660   }
80661   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80662   return jresult;
80663 }
80664
80665
80666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
80667   void * jresult ;
80668   Dali::Toolkit::Slider *result = 0 ;
80669
80670   {
80671     try {
80672       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
80673     } catch (std::out_of_range& e) {
80674       {
80675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80676       };
80677     } catch (std::exception& e) {
80678       {
80679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80680       };
80681     } catch (...) {
80682       {
80683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80684       };
80685     }
80686   }
80687   jresult = (void *)result;
80688   return jresult;
80689 }
80690
80691
80692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
80693   void * jresult ;
80694   Dali::Toolkit::Slider *arg1 = 0 ;
80695   Dali::Toolkit::Slider *result = 0 ;
80696
80697   arg1 = (Dali::Toolkit::Slider *)jarg1;
80698   if (!arg1) {
80699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80700     return 0;
80701   }
80702   {
80703     try {
80704       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
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 (...) {
80714       {
80715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80716       };
80717     }
80718   }
80719   jresult = (void *)result;
80720   return jresult;
80721 }
80722
80723
80724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
80725   void * jresult ;
80726   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80727   Dali::Toolkit::Slider *arg2 = 0 ;
80728   Dali::Toolkit::Slider *result = 0 ;
80729
80730   arg1 = (Dali::Toolkit::Slider *)jarg1;
80731   arg2 = (Dali::Toolkit::Slider *)jarg2;
80732   if (!arg2) {
80733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80734     return 0;
80735   }
80736   {
80737     try {
80738       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
80739     } catch (std::out_of_range& e) {
80740       {
80741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80742       };
80743     } catch (std::exception& e) {
80744       {
80745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80746       };
80747     } catch (...) {
80748       {
80749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80750       };
80751     }
80752   }
80753   jresult = (void *)result;
80754   return jresult;
80755 }
80756
80757
80758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
80759   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80760
80761   arg1 = (Dali::Toolkit::Slider *)jarg1;
80762   {
80763     try {
80764       delete arg1;
80765     } catch (std::out_of_range& e) {
80766       {
80767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80768       };
80769     } catch (std::exception& e) {
80770       {
80771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80772       };
80773     } catch (...) {
80774       {
80775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80776       };
80777     }
80778   }
80779 }
80780
80781
80782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
80783   void * jresult ;
80784   Dali::BaseHandle arg1 ;
80785   Dali::BaseHandle *argp1 ;
80786   Dali::Toolkit::Slider result;
80787
80788   argp1 = (Dali::BaseHandle *)jarg1;
80789   if (!argp1) {
80790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80791     return 0;
80792   }
80793   arg1 = *argp1;
80794   {
80795     try {
80796       result = Dali::Toolkit::Slider::DownCast(arg1);
80797     } catch (std::out_of_range& e) {
80798       {
80799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80800       };
80801     } catch (std::exception& e) {
80802       {
80803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80804       };
80805     } catch (...) {
80806       {
80807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80808       };
80809     }
80810   }
80811   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80812   return jresult;
80813 }
80814
80815
80816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
80817   void * jresult ;
80818   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80819   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
80820
80821   arg1 = (Dali::Toolkit::Slider *)jarg1;
80822   {
80823     try {
80824       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
80825     } catch (std::out_of_range& e) {
80826       {
80827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80828       };
80829     } catch (std::exception& e) {
80830       {
80831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80832       };
80833     } catch (...) {
80834       {
80835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80836       };
80837     }
80838   }
80839   jresult = (void *)result;
80840   return jresult;
80841 }
80842
80843
80844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
80845   void * jresult ;
80846   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80847   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
80848
80849   arg1 = (Dali::Toolkit::Slider *)jarg1;
80850   {
80851     try {
80852       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
80853     } catch (std::out_of_range& e) {
80854       {
80855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80856       };
80857     } catch (std::exception& e) {
80858       {
80859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80860       };
80861     } catch (...) {
80862       {
80863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80864       };
80865     }
80866   }
80867   jresult = (void *)result;
80868   return jresult;
80869 }
80870
80871
80872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
80873   void * jresult ;
80874   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80875   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
80876
80877   arg1 = (Dali::Toolkit::Slider *)jarg1;
80878   {
80879     try {
80880       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
80881     } catch (std::out_of_range& e) {
80882       {
80883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80884       };
80885     } catch (std::exception& e) {
80886       {
80887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80888       };
80889     } catch (...) {
80890       {
80891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80892       };
80893     }
80894   }
80895   jresult = (void *)result;
80896   return jresult;
80897 }
80898
80899
80900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
80901   int jresult ;
80902   int result;
80903
80904   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
80905   jresult = (int)result;
80906   return jresult;
80907 }
80908
80909
80910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
80911   int jresult ;
80912   int result;
80913
80914   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
80915   jresult = (int)result;
80916   return jresult;
80917 }
80918
80919
80920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
80921   int jresult ;
80922   int result;
80923
80924   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
80925   jresult = (int)result;
80926   return jresult;
80927 }
80928
80929
80930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
80931   int jresult ;
80932   int result;
80933
80934   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
80935   jresult = (int)result;
80936   return jresult;
80937 }
80938
80939
80940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
80941   void * jresult ;
80942   Dali::Toolkit::VideoView::Property *result = 0 ;
80943
80944   {
80945     try {
80946       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
80947     } catch (std::out_of_range& e) {
80948       {
80949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80950       };
80951     } catch (std::exception& e) {
80952       {
80953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80954       };
80955     } catch (...) {
80956       {
80957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80958       };
80959     }
80960   }
80961   jresult = (void *)result;
80962   return jresult;
80963 }
80964
80965
80966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
80967   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
80968
80969   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
80970   {
80971     try {
80972       delete arg1;
80973     } catch (std::out_of_range& e) {
80974       {
80975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80976       };
80977     } catch (std::exception& e) {
80978       {
80979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80980       };
80981     } catch (...) {
80982       {
80983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80984       };
80985     }
80986   }
80987 }
80988
80989
80990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
80991   void * jresult ;
80992   Dali::Toolkit::VideoView result;
80993
80994   {
80995     try {
80996       result = Dali::Toolkit::VideoView::New();
80997     } catch (std::out_of_range& e) {
80998       {
80999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81000       };
81001     } catch (std::exception& e) {
81002       {
81003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81004       };
81005     } catch (...) {
81006       {
81007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81008       };
81009     }
81010   }
81011   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81012   return jresult;
81013 }
81014
81015
81016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81017   void * jresult ;
81018   std::string *arg1 = 0 ;
81019   Dali::Toolkit::VideoView result;
81020
81021   if (!jarg1) {
81022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81023     return 0;
81024   }
81025   std::string arg1_str(jarg1);
81026   arg1 = &arg1_str;
81027   {
81028     try {
81029       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81030     } catch (std::out_of_range& e) {
81031       {
81032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81033       };
81034     } catch (std::exception& e) {
81035       {
81036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81037       };
81038     } catch (...) {
81039       {
81040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81041       };
81042     }
81043   }
81044   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81045
81046   //argout typemap for const std::string&
81047
81048   return jresult;
81049 }
81050
81051
81052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81053   void * jresult ;
81054   Dali::Toolkit::VideoView *result = 0 ;
81055
81056   {
81057     try {
81058       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81059     } catch (std::out_of_range& e) {
81060       {
81061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81062       };
81063     } catch (std::exception& e) {
81064       {
81065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81066       };
81067     } catch (...) {
81068       {
81069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81070       };
81071     }
81072   }
81073   jresult = (void *)result;
81074   return jresult;
81075 }
81076
81077
81078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81079   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81080
81081   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81082   {
81083     try {
81084       delete arg1;
81085     } catch (std::out_of_range& e) {
81086       {
81087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81088       };
81089     } catch (std::exception& e) {
81090       {
81091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81092       };
81093     } catch (...) {
81094       {
81095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81096       };
81097     }
81098   }
81099 }
81100
81101
81102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81103   void * jresult ;
81104   Dali::Toolkit::VideoView *arg1 = 0 ;
81105   Dali::Toolkit::VideoView *result = 0 ;
81106
81107   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81108   if (!arg1) {
81109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81110     return 0;
81111   }
81112   {
81113     try {
81114       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81115     } catch (std::out_of_range& e) {
81116       {
81117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81118       };
81119     } catch (std::exception& e) {
81120       {
81121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81122       };
81123     } catch (...) {
81124       {
81125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81126       };
81127     }
81128   }
81129   jresult = (void *)result;
81130   return jresult;
81131 }
81132
81133
81134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
81135   void * jresult ;
81136   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81137   Dali::Toolkit::VideoView *arg2 = 0 ;
81138   Dali::Toolkit::VideoView *result = 0 ;
81139
81140   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81141   arg2 = (Dali::Toolkit::VideoView *)jarg2;
81142   if (!arg2) {
81143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81144     return 0;
81145   }
81146   {
81147     try {
81148       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
81149     } catch (std::out_of_range& e) {
81150       {
81151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81152       };
81153     } catch (std::exception& e) {
81154       {
81155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81156       };
81157     } catch (...) {
81158       {
81159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81160       };
81161     }
81162   }
81163   jresult = (void *)result;
81164   return jresult;
81165 }
81166
81167
81168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
81169   void * jresult ;
81170   Dali::BaseHandle arg1 ;
81171   Dali::BaseHandle *argp1 ;
81172   Dali::Toolkit::VideoView result;
81173
81174   argp1 = (Dali::BaseHandle *)jarg1;
81175   if (!argp1) {
81176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81177     return 0;
81178   }
81179   arg1 = *argp1;
81180   {
81181     try {
81182       result = Dali::Toolkit::VideoView::DownCast(arg1);
81183     } catch (std::out_of_range& e) {
81184       {
81185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81186       };
81187     } catch (std::exception& e) {
81188       {
81189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81190       };
81191     } catch (...) {
81192       {
81193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81194       };
81195     }
81196   }
81197   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81198   return jresult;
81199 }
81200
81201
81202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
81203   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81204
81205   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81206   {
81207     try {
81208       (arg1)->Play();
81209     } catch (std::out_of_range& e) {
81210       {
81211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81212       };
81213     } catch (std::exception& e) {
81214       {
81215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81216       };
81217     } catch (...) {
81218       {
81219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81220       };
81221     }
81222   }
81223 }
81224
81225
81226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
81227   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81228
81229   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81230   {
81231     try {
81232       (arg1)->Pause();
81233     } catch (std::out_of_range& e) {
81234       {
81235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81236       };
81237     } catch (std::exception& e) {
81238       {
81239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81240       };
81241     } catch (...) {
81242       {
81243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81244       };
81245     }
81246   }
81247 }
81248
81249
81250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
81251   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81252
81253   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81254   {
81255     try {
81256       (arg1)->Stop();
81257     } catch (std::out_of_range& e) {
81258       {
81259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81260       };
81261     } catch (std::exception& e) {
81262       {
81263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81264       };
81265     } catch (...) {
81266       {
81267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81268       };
81269     }
81270   }
81271 }
81272
81273
81274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
81275   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81276   int arg2 ;
81277
81278   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81279   arg2 = (int)jarg2;
81280   {
81281     try {
81282       (arg1)->Forward(arg2);
81283     } catch (std::out_of_range& e) {
81284       {
81285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81286       };
81287     } catch (std::exception& e) {
81288       {
81289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81290       };
81291     } catch (...) {
81292       {
81293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81294       };
81295     }
81296   }
81297 }
81298
81299
81300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
81301   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81302   int arg2 ;
81303
81304   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81305   arg2 = (int)jarg2;
81306   {
81307     try {
81308       (arg1)->Backward(arg2);
81309     } catch (std::out_of_range& e) {
81310       {
81311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81312       };
81313     } catch (std::exception& e) {
81314       {
81315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81316       };
81317     } catch (...) {
81318       {
81319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81320       };
81321     }
81322   }
81323 }
81324
81325
81326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
81327   void * jresult ;
81328   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81329   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
81330
81331   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81332   {
81333     try {
81334       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
81335     } catch (std::out_of_range& e) {
81336       {
81337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81338       };
81339     } catch (std::exception& e) {
81340       {
81341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81342       };
81343     } catch (...) {
81344       {
81345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81346       };
81347     }
81348   }
81349   jresult = (void *)result;
81350   return jresult;
81351 }
81352
81353
81354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
81355   int jresult ;
81356   int result;
81357
81358   result = (int)Dali::Toolkit::Popup::Property::TITLE;
81359   jresult = (int)result;
81360   return jresult;
81361 }
81362
81363
81364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
81365   int jresult ;
81366   int result;
81367
81368   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
81369   jresult = (int)result;
81370   return jresult;
81371 }
81372
81373
81374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
81375   int jresult ;
81376   int result;
81377
81378   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
81379   jresult = (int)result;
81380   return jresult;
81381 }
81382
81383
81384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
81385   int jresult ;
81386   int result;
81387
81388   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
81389   jresult = (int)result;
81390   return jresult;
81391 }
81392
81393
81394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
81395   int jresult ;
81396   int result;
81397
81398   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
81399   jresult = (int)result;
81400   return jresult;
81401 }
81402
81403
81404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
81405   int jresult ;
81406   int result;
81407
81408   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
81409   jresult = (int)result;
81410   return jresult;
81411 }
81412
81413
81414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
81415   int jresult ;
81416   int result;
81417
81418   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
81419   jresult = (int)result;
81420   return jresult;
81421 }
81422
81423
81424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
81425   int jresult ;
81426   int result;
81427
81428   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
81429   jresult = (int)result;
81430   return jresult;
81431 }
81432
81433
81434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
81435   int jresult ;
81436   int result;
81437
81438   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
81439   jresult = (int)result;
81440   return jresult;
81441 }
81442
81443
81444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
81445   int jresult ;
81446   int result;
81447
81448   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
81449   jresult = (int)result;
81450   return jresult;
81451 }
81452
81453
81454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
81455   int jresult ;
81456   int result;
81457
81458   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
81459   jresult = (int)result;
81460   return jresult;
81461 }
81462
81463
81464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
81465   int jresult ;
81466   int result;
81467
81468   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
81469   jresult = (int)result;
81470   return jresult;
81471 }
81472
81473
81474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
81475   int jresult ;
81476   int result;
81477
81478   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
81479   jresult = (int)result;
81480   return jresult;
81481 }
81482
81483
81484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
81485   int jresult ;
81486   int result;
81487
81488   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
81489   jresult = (int)result;
81490   return jresult;
81491 }
81492
81493
81494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
81495   int jresult ;
81496   int result;
81497
81498   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
81499   jresult = (int)result;
81500   return jresult;
81501 }
81502
81503
81504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
81505   int jresult ;
81506   int result;
81507
81508   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
81509   jresult = (int)result;
81510   return jresult;
81511 }
81512
81513
81514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
81515   int jresult ;
81516   int result;
81517
81518   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
81519   jresult = (int)result;
81520   return jresult;
81521 }
81522
81523
81524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
81525   int jresult ;
81526   int result;
81527
81528   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
81529   jresult = (int)result;
81530   return jresult;
81531 }
81532
81533
81534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
81535   int jresult ;
81536   int result;
81537
81538   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
81539   jresult = (int)result;
81540   return jresult;
81541 }
81542
81543
81544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
81545   int jresult ;
81546   int result;
81547
81548   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
81549   jresult = (int)result;
81550   return jresult;
81551 }
81552
81553
81554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
81555   int jresult ;
81556   int result;
81557
81558   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
81559   jresult = (int)result;
81560   return jresult;
81561 }
81562
81563
81564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
81565   void * jresult ;
81566   Dali::Toolkit::Popup::Property *result = 0 ;
81567
81568   {
81569     try {
81570       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
81571     } catch (std::out_of_range& e) {
81572       {
81573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81574       };
81575     } catch (std::exception& e) {
81576       {
81577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81578       };
81579     } catch (...) {
81580       {
81581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81582       };
81583     }
81584   }
81585   jresult = (void *)result;
81586   return jresult;
81587 }
81588
81589
81590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
81591   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
81592
81593   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
81594   {
81595     try {
81596       delete arg1;
81597     } catch (std::out_of_range& e) {
81598       {
81599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81600       };
81601     } catch (std::exception& e) {
81602       {
81603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81604       };
81605     } catch (...) {
81606       {
81607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81608       };
81609     }
81610   }
81611 }
81612
81613
81614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
81615   void * jresult ;
81616   Dali::Toolkit::Popup *result = 0 ;
81617
81618   {
81619     try {
81620       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
81621     } catch (std::out_of_range& e) {
81622       {
81623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81624       };
81625     } catch (std::exception& e) {
81626       {
81627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81628       };
81629     } catch (...) {
81630       {
81631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81632       };
81633     }
81634   }
81635   jresult = (void *)result;
81636   return jresult;
81637 }
81638
81639
81640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
81641   void * jresult ;
81642   Dali::Toolkit::Popup result;
81643
81644   {
81645     try {
81646       result = Dali::Toolkit::Popup::New();
81647     } catch (std::out_of_range& e) {
81648       {
81649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81650       };
81651     } catch (std::exception& e) {
81652       {
81653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81654       };
81655     } catch (...) {
81656       {
81657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81658       };
81659     }
81660   }
81661   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81662   return jresult;
81663 }
81664
81665
81666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
81667   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81668
81669   arg1 = (Dali::Toolkit::Popup *)jarg1;
81670   {
81671     try {
81672       delete arg1;
81673     } catch (std::out_of_range& e) {
81674       {
81675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81676       };
81677     } catch (std::exception& e) {
81678       {
81679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81680       };
81681     } catch (...) {
81682       {
81683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81684       };
81685     }
81686   }
81687 }
81688
81689
81690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
81691   void * jresult ;
81692   Dali::Toolkit::Popup *arg1 = 0 ;
81693   Dali::Toolkit::Popup *result = 0 ;
81694
81695   arg1 = (Dali::Toolkit::Popup *)jarg1;
81696   if (!arg1) {
81697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81698     return 0;
81699   }
81700   {
81701     try {
81702       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
81703     } catch (std::out_of_range& e) {
81704       {
81705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81706       };
81707     } catch (std::exception& e) {
81708       {
81709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81710       };
81711     } catch (...) {
81712       {
81713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81714       };
81715     }
81716   }
81717   jresult = (void *)result;
81718   return jresult;
81719 }
81720
81721
81722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
81723   void * jresult ;
81724   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81725   Dali::Toolkit::Popup *arg2 = 0 ;
81726   Dali::Toolkit::Popup *result = 0 ;
81727
81728   arg1 = (Dali::Toolkit::Popup *)jarg1;
81729   arg2 = (Dali::Toolkit::Popup *)jarg2;
81730   if (!arg2) {
81731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81732     return 0;
81733   }
81734   {
81735     try {
81736       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
81737     } catch (std::out_of_range& e) {
81738       {
81739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81740       };
81741     } catch (std::exception& e) {
81742       {
81743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81744       };
81745     } catch (...) {
81746       {
81747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81748       };
81749     }
81750   }
81751   jresult = (void *)result;
81752   return jresult;
81753 }
81754
81755
81756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
81757   void * jresult ;
81758   Dali::BaseHandle arg1 ;
81759   Dali::BaseHandle *argp1 ;
81760   Dali::Toolkit::Popup result;
81761
81762   argp1 = (Dali::BaseHandle *)jarg1;
81763   if (!argp1) {
81764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81765     return 0;
81766   }
81767   arg1 = *argp1;
81768   {
81769     try {
81770       result = Dali::Toolkit::Popup::DownCast(arg1);
81771     } catch (std::out_of_range& e) {
81772       {
81773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81774       };
81775     } catch (std::exception& e) {
81776       {
81777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81778       };
81779     } catch (...) {
81780       {
81781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81782       };
81783     }
81784   }
81785   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81786   return jresult;
81787 }
81788
81789
81790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
81791   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81792   Dali::Actor arg2 ;
81793   Dali::Actor *argp2 ;
81794
81795   arg1 = (Dali::Toolkit::Popup *)jarg1;
81796   argp2 = (Dali::Actor *)jarg2;
81797   if (!argp2) {
81798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81799     return ;
81800   }
81801   arg2 = *argp2;
81802   {
81803     try {
81804       (arg1)->SetTitle(arg2);
81805     } catch (std::out_of_range& e) {
81806       {
81807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81808       };
81809     } catch (std::exception& e) {
81810       {
81811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81812       };
81813     } catch (...) {
81814       {
81815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81816       };
81817     }
81818   }
81819 }
81820
81821
81822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
81823   void * jresult ;
81824   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81825   Dali::Actor result;
81826
81827   arg1 = (Dali::Toolkit::Popup *)jarg1;
81828   {
81829     try {
81830       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
81831     } catch (std::out_of_range& e) {
81832       {
81833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81834       };
81835     } catch (std::exception& e) {
81836       {
81837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81838       };
81839     } catch (...) {
81840       {
81841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81842       };
81843     }
81844   }
81845   jresult = new Dali::Actor((const Dali::Actor &)result);
81846   return jresult;
81847 }
81848
81849
81850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
81851   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81852   Dali::Actor arg2 ;
81853   Dali::Actor *argp2 ;
81854
81855   arg1 = (Dali::Toolkit::Popup *)jarg1;
81856   argp2 = (Dali::Actor *)jarg2;
81857   if (!argp2) {
81858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81859     return ;
81860   }
81861   arg2 = *argp2;
81862   {
81863     try {
81864       (arg1)->SetContent(arg2);
81865     } catch (std::out_of_range& e) {
81866       {
81867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81868       };
81869     } catch (std::exception& e) {
81870       {
81871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81872       };
81873     } catch (...) {
81874       {
81875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81876       };
81877     }
81878   }
81879 }
81880
81881
81882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
81883   void * jresult ;
81884   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81885   Dali::Actor result;
81886
81887   arg1 = (Dali::Toolkit::Popup *)jarg1;
81888   {
81889     try {
81890       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
81891     } catch (std::out_of_range& e) {
81892       {
81893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81894       };
81895     } catch (std::exception& e) {
81896       {
81897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81898       };
81899     } catch (...) {
81900       {
81901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81902       };
81903     }
81904   }
81905   jresult = new Dali::Actor((const Dali::Actor &)result);
81906   return jresult;
81907 }
81908
81909
81910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
81911   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81912   Dali::Actor arg2 ;
81913   Dali::Actor *argp2 ;
81914
81915   arg1 = (Dali::Toolkit::Popup *)jarg1;
81916   argp2 = (Dali::Actor *)jarg2;
81917   if (!argp2) {
81918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81919     return ;
81920   }
81921   arg2 = *argp2;
81922   {
81923     try {
81924       (arg1)->SetFooter(arg2);
81925     } catch (std::out_of_range& e) {
81926       {
81927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81928       };
81929     } catch (std::exception& e) {
81930       {
81931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81932       };
81933     } catch (...) {
81934       {
81935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81936       };
81937     }
81938   }
81939 }
81940
81941
81942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
81943   void * jresult ;
81944   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81945   Dali::Actor result;
81946
81947   arg1 = (Dali::Toolkit::Popup *)jarg1;
81948   {
81949     try {
81950       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
81951     } catch (std::out_of_range& e) {
81952       {
81953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81954       };
81955     } catch (std::exception& e) {
81956       {
81957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81958       };
81959     } catch (...) {
81960       {
81961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81962       };
81963     }
81964   }
81965   jresult = new Dali::Actor((const Dali::Actor &)result);
81966   return jresult;
81967 }
81968
81969
81970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
81971   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81972   Dali::Toolkit::Popup::DisplayState arg2 ;
81973
81974   arg1 = (Dali::Toolkit::Popup *)jarg1;
81975   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
81976   {
81977     try {
81978       (arg1)->SetDisplayState(arg2);
81979     } catch (std::out_of_range& e) {
81980       {
81981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81982       };
81983     } catch (std::exception& e) {
81984       {
81985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81986       };
81987     } catch (...) {
81988       {
81989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81990       };
81991     }
81992   }
81993 }
81994
81995
81996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
81997   int jresult ;
81998   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81999   Dali::Toolkit::Popup::DisplayState result;
82000
82001   arg1 = (Dali::Toolkit::Popup *)jarg1;
82002   {
82003     try {
82004       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82005     } catch (std::out_of_range& e) {
82006       {
82007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82008       };
82009     } catch (std::exception& e) {
82010       {
82011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82012       };
82013     } catch (...) {
82014       {
82015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82016       };
82017     }
82018   }
82019   jresult = (int)result;
82020   return jresult;
82021 }
82022
82023
82024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
82025   void * jresult ;
82026   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82027   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82028
82029   arg1 = (Dali::Toolkit::Popup *)jarg1;
82030   {
82031     try {
82032       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82033     } catch (std::out_of_range& e) {
82034       {
82035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82036       };
82037     } catch (std::exception& e) {
82038       {
82039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82040       };
82041     } catch (...) {
82042       {
82043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82044       };
82045     }
82046   }
82047   jresult = (void *)result;
82048   return jresult;
82049 }
82050
82051
82052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
82053   void * jresult ;
82054   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82055   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82056
82057   arg1 = (Dali::Toolkit::Popup *)jarg1;
82058   {
82059     try {
82060       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
82061     } catch (std::out_of_range& e) {
82062       {
82063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82064       };
82065     } catch (std::exception& e) {
82066       {
82067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82068       };
82069     } catch (...) {
82070       {
82071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82072       };
82073     }
82074   }
82075   jresult = (void *)result;
82076   return jresult;
82077 }
82078
82079
82080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
82081   void * jresult ;
82082   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82083   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82084
82085   arg1 = (Dali::Toolkit::Popup *)jarg1;
82086   {
82087     try {
82088       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
82089     } catch (std::out_of_range& e) {
82090       {
82091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82092       };
82093     } catch (std::exception& e) {
82094       {
82095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82096       };
82097     } catch (...) {
82098       {
82099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82100       };
82101     }
82102   }
82103   jresult = (void *)result;
82104   return jresult;
82105 }
82106
82107
82108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
82109   void * jresult ;
82110   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82111   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82112
82113   arg1 = (Dali::Toolkit::Popup *)jarg1;
82114   {
82115     try {
82116       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
82117     } catch (std::out_of_range& e) {
82118       {
82119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82120       };
82121     } catch (std::exception& e) {
82122       {
82123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82124       };
82125     } catch (...) {
82126       {
82127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82128       };
82129     }
82130   }
82131   jresult = (void *)result;
82132   return jresult;
82133 }
82134
82135
82136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
82137   void * jresult ;
82138   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82139   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82140
82141   arg1 = (Dali::Toolkit::Popup *)jarg1;
82142   {
82143     try {
82144       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
82145     } catch (std::out_of_range& e) {
82146       {
82147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82148       };
82149     } catch (std::exception& e) {
82150       {
82151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82152       };
82153     } catch (...) {
82154       {
82155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82156       };
82157     }
82158   }
82159   jresult = (void *)result;
82160   return jresult;
82161 }
82162
82163
82164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
82165   int jresult ;
82166   int result;
82167
82168   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
82169   jresult = (int)result;
82170   return jresult;
82171 }
82172
82173
82174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
82175   int jresult ;
82176   int result;
82177
82178   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
82179   jresult = (int)result;
82180   return jresult;
82181 }
82182
82183
82184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
82185   int jresult ;
82186   int result;
82187
82188   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
82189   jresult = (int)result;
82190   return jresult;
82191 }
82192
82193
82194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
82195   int jresult ;
82196   int result;
82197
82198   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
82199   jresult = (int)result;
82200   return jresult;
82201 }
82202
82203
82204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
82205   int jresult ;
82206   int result;
82207
82208   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
82209   jresult = (int)result;
82210   return jresult;
82211 }
82212
82213
82214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
82215   int jresult ;
82216   int result;
82217
82218   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
82219   jresult = (int)result;
82220   return jresult;
82221 }
82222
82223
82224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
82225   int jresult ;
82226   int result;
82227
82228   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
82229   jresult = (int)result;
82230   return jresult;
82231 }
82232
82233
82234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
82235   int jresult ;
82236   int result;
82237
82238   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
82239   jresult = (int)result;
82240   return jresult;
82241 }
82242
82243
82244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
82245   int jresult ;
82246   int result;
82247
82248   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
82249   jresult = (int)result;
82250   return jresult;
82251 }
82252
82253
82254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
82255   void * jresult ;
82256   Dali::Toolkit::ProgressBar::Property *result = 0 ;
82257
82258   {
82259     try {
82260       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
82261     } catch (std::out_of_range& e) {
82262       {
82263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82264       };
82265     } catch (std::exception& e) {
82266       {
82267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82268       };
82269     } catch (...) {
82270       {
82271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82272       };
82273     }
82274   }
82275   jresult = (void *)result;
82276   return jresult;
82277 }
82278
82279
82280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
82281   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
82282
82283   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
82284   {
82285     try {
82286       delete arg1;
82287     } catch (std::out_of_range& e) {
82288       {
82289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82290       };
82291     } catch (std::exception& e) {
82292       {
82293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82294       };
82295     } catch (...) {
82296       {
82297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82298       };
82299     }
82300   }
82301 }
82302
82303
82304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
82305   void * jresult ;
82306   Dali::Toolkit::ProgressBar result;
82307
82308   {
82309     try {
82310       result = Dali::Toolkit::ProgressBar::New();
82311     } catch (std::out_of_range& e) {
82312       {
82313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82314       };
82315     } catch (std::exception& e) {
82316       {
82317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82318       };
82319     } catch (...) {
82320       {
82321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82322       };
82323     }
82324   }
82325   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82326   return jresult;
82327 }
82328
82329
82330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
82331   void * jresult ;
82332   Dali::Toolkit::ProgressBar *result = 0 ;
82333
82334   {
82335     try {
82336       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
82337     } catch (std::out_of_range& e) {
82338       {
82339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82340       };
82341     } catch (std::exception& e) {
82342       {
82343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82344       };
82345     } catch (...) {
82346       {
82347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82348       };
82349     }
82350   }
82351   jresult = (void *)result;
82352   return jresult;
82353 }
82354
82355
82356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
82357   void * jresult ;
82358   Dali::Toolkit::ProgressBar *arg1 = 0 ;
82359   Dali::Toolkit::ProgressBar *result = 0 ;
82360
82361   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82362   if (!arg1) {
82363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82364     return 0;
82365   }
82366   {
82367     try {
82368       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
82369     } catch (std::out_of_range& e) {
82370       {
82371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82372       };
82373     } catch (std::exception& e) {
82374       {
82375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82376       };
82377     } catch (...) {
82378       {
82379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82380       };
82381     }
82382   }
82383   jresult = (void *)result;
82384   return jresult;
82385 }
82386
82387
82388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
82389   void * jresult ;
82390   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82391   Dali::Toolkit::ProgressBar *arg2 = 0 ;
82392   Dali::Toolkit::ProgressBar *result = 0 ;
82393
82394   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82395   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
82396   if (!arg2) {
82397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82398     return 0;
82399   }
82400   {
82401     try {
82402       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
82403     } catch (std::out_of_range& e) {
82404       {
82405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82406       };
82407     } catch (std::exception& e) {
82408       {
82409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82410       };
82411     } catch (...) {
82412       {
82413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82414       };
82415     }
82416   }
82417   jresult = (void *)result;
82418   return jresult;
82419 }
82420
82421
82422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
82423   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82424
82425   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82426   {
82427     try {
82428       delete arg1;
82429     } catch (std::out_of_range& e) {
82430       {
82431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82432       };
82433     } catch (std::exception& e) {
82434       {
82435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82436       };
82437     } catch (...) {
82438       {
82439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82440       };
82441     }
82442   }
82443 }
82444
82445
82446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
82447   void * jresult ;
82448   Dali::BaseHandle arg1 ;
82449   Dali::BaseHandle *argp1 ;
82450   Dali::Toolkit::ProgressBar result;
82451
82452   argp1 = (Dali::BaseHandle *)jarg1;
82453   if (!argp1) {
82454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82455     return 0;
82456   }
82457   arg1 = *argp1;
82458   {
82459     try {
82460       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
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 (...) {
82470       {
82471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82472       };
82473     }
82474   }
82475   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82476   return jresult;
82477 }
82478
82479
82480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
82481   void * jresult ;
82482   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82483   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
82484
82485   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82486   {
82487     try {
82488       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82489     } catch (std::out_of_range& e) {
82490       {
82491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82492       };
82493     } catch (std::exception& e) {
82494       {
82495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82496       };
82497     } catch (...) {
82498       {
82499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82500       };
82501     }
82502   }
82503   jresult = (void *)result;
82504   return jresult;
82505 }
82506
82507
82508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
82509   void * jresult ;
82510   Dali::Toolkit::GaussianBlurView *result = 0 ;
82511
82512   {
82513     try {
82514       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
82515     } catch (std::out_of_range& e) {
82516       {
82517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82518       };
82519     } catch (std::exception& e) {
82520       {
82521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82522       };
82523     } catch (...) {
82524       {
82525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82526       };
82527     }
82528   }
82529   jresult = (void *)result;
82530   return jresult;
82531 }
82532
82533
82534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
82535   void * jresult ;
82536   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
82537   Dali::Toolkit::GaussianBlurView *result = 0 ;
82538
82539   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82540   if (!arg1) {
82541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82542     return 0;
82543   }
82544   {
82545     try {
82546       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
82547     } catch (std::out_of_range& e) {
82548       {
82549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82550       };
82551     } catch (std::exception& e) {
82552       {
82553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82554       };
82555     } catch (...) {
82556       {
82557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82558       };
82559     }
82560   }
82561   jresult = (void *)result;
82562   return jresult;
82563 }
82564
82565
82566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
82567   void * jresult ;
82568   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82569   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
82570   Dali::Toolkit::GaussianBlurView *result = 0 ;
82571
82572   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82573   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
82574   if (!arg2) {
82575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82576     return 0;
82577   }
82578   {
82579     try {
82580       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
82581     } catch (std::out_of_range& e) {
82582       {
82583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82584       };
82585     } catch (std::exception& e) {
82586       {
82587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82588       };
82589     } catch (...) {
82590       {
82591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82592       };
82593     }
82594   }
82595   jresult = (void *)result;
82596   return jresult;
82597 }
82598
82599
82600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
82601   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82602
82603   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82604   {
82605     try {
82606       delete arg1;
82607     } catch (std::out_of_range& e) {
82608       {
82609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82610       };
82611     } catch (std::exception& e) {
82612       {
82613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82614       };
82615     } catch (...) {
82616       {
82617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82618       };
82619     }
82620   }
82621 }
82622
82623
82624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
82625   void * jresult ;
82626   Dali::BaseHandle arg1 ;
82627   Dali::BaseHandle *argp1 ;
82628   Dali::Toolkit::GaussianBlurView result;
82629
82630   argp1 = (Dali::BaseHandle *)jarg1;
82631   if (!argp1) {
82632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82633     return 0;
82634   }
82635   arg1 = *argp1;
82636   {
82637     try {
82638       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
82639     } catch (std::out_of_range& e) {
82640       {
82641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82642       };
82643     } catch (std::exception& e) {
82644       {
82645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82646       };
82647     } catch (...) {
82648       {
82649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82650       };
82651     }
82652   }
82653   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82654   return jresult;
82655 }
82656
82657
82658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
82659   void * jresult ;
82660   Dali::Toolkit::GaussianBlurView result;
82661
82662   {
82663     try {
82664       result = Dali::Toolkit::GaussianBlurView::New();
82665     } catch (std::out_of_range& e) {
82666       {
82667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82668       };
82669     } catch (std::exception& e) {
82670       {
82671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82672       };
82673     } catch (...) {
82674       {
82675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82676       };
82677     }
82678   }
82679   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82680   return jresult;
82681 }
82682
82683
82684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
82685   void * jresult ;
82686   unsigned int arg1 ;
82687   float arg2 ;
82688   Dali::Pixel::Format arg3 ;
82689   float arg4 ;
82690   float arg5 ;
82691   bool arg6 ;
82692   Dali::Toolkit::GaussianBlurView result;
82693
82694   arg1 = (unsigned int)jarg1;
82695   arg2 = (float)jarg2;
82696   arg3 = (Dali::Pixel::Format)jarg3;
82697   arg4 = (float)jarg4;
82698   arg5 = (float)jarg5;
82699   arg6 = jarg6 ? true : false;
82700   {
82701     try {
82702       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
82703     } catch (std::out_of_range& e) {
82704       {
82705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82706       };
82707     } catch (std::exception& e) {
82708       {
82709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82710       };
82711     } catch (...) {
82712       {
82713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82714       };
82715     }
82716   }
82717   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82718   return jresult;
82719 }
82720
82721
82722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
82723   void * jresult ;
82724   unsigned int arg1 ;
82725   float arg2 ;
82726   Dali::Pixel::Format arg3 ;
82727   float arg4 ;
82728   float arg5 ;
82729   Dali::Toolkit::GaussianBlurView result;
82730
82731   arg1 = (unsigned int)jarg1;
82732   arg2 = (float)jarg2;
82733   arg3 = (Dali::Pixel::Format)jarg3;
82734   arg4 = (float)jarg4;
82735   arg5 = (float)jarg5;
82736   {
82737     try {
82738       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
82739     } catch (std::out_of_range& e) {
82740       {
82741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82742       };
82743     } catch (std::exception& e) {
82744       {
82745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82746       };
82747     } catch (...) {
82748       {
82749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82750       };
82751     }
82752   }
82753   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82754   return jresult;
82755 }
82756
82757
82758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
82759   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82760   Dali::Actor arg2 ;
82761   Dali::Actor *argp2 ;
82762
82763   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82764   argp2 = (Dali::Actor *)jarg2;
82765   if (!argp2) {
82766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82767     return ;
82768   }
82769   arg2 = *argp2;
82770   {
82771     try {
82772       (arg1)->Add(arg2);
82773     } catch (std::out_of_range& e) {
82774       {
82775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82776       };
82777     } catch (std::exception& e) {
82778       {
82779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82780       };
82781     } catch (...) {
82782       {
82783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82784       };
82785     }
82786   }
82787 }
82788
82789
82790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
82791   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82792   Dali::Actor arg2 ;
82793   Dali::Actor *argp2 ;
82794
82795   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82796   argp2 = (Dali::Actor *)jarg2;
82797   if (!argp2) {
82798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82799     return ;
82800   }
82801   arg2 = *argp2;
82802   {
82803     try {
82804       (arg1)->Remove(arg2);
82805     } catch (std::out_of_range& e) {
82806       {
82807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82808       };
82809     } catch (std::exception& e) {
82810       {
82811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82812       };
82813     } catch (...) {
82814       {
82815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82816       };
82817     }
82818   }
82819 }
82820
82821
82822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
82823   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82824
82825   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82826   {
82827     try {
82828       (arg1)->Activate();
82829     } catch (std::out_of_range& e) {
82830       {
82831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82832       };
82833     } catch (std::exception& e) {
82834       {
82835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82836       };
82837     } catch (...) {
82838       {
82839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82840       };
82841     }
82842   }
82843 }
82844
82845
82846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
82847   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82848
82849   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82850   {
82851     try {
82852       (arg1)->ActivateOnce();
82853     } catch (std::out_of_range& e) {
82854       {
82855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82856       };
82857     } catch (std::exception& e) {
82858       {
82859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82860       };
82861     } catch (...) {
82862       {
82863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82864       };
82865     }
82866   }
82867 }
82868
82869
82870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
82871   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82872
82873   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82874   {
82875     try {
82876       (arg1)->Deactivate();
82877     } catch (std::out_of_range& e) {
82878       {
82879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82880       };
82881     } catch (std::exception& e) {
82882       {
82883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82884       };
82885     } catch (...) {
82886       {
82887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82888       };
82889     }
82890   }
82891 }
82892
82893
82894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
82895   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82896   Dali::Image arg2 ;
82897   Dali::FrameBufferImage arg3 ;
82898   Dali::Image *argp2 ;
82899   Dali::FrameBufferImage *argp3 ;
82900
82901   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82902   argp2 = (Dali::Image *)jarg2;
82903   if (!argp2) {
82904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
82905     return ;
82906   }
82907   arg2 = *argp2;
82908   argp3 = (Dali::FrameBufferImage *)jarg3;
82909   if (!argp3) {
82910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
82911     return ;
82912   }
82913   arg3 = *argp3;
82914   {
82915     try {
82916       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
82917     } catch (std::out_of_range& e) {
82918       {
82919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82920       };
82921     } catch (std::exception& e) {
82922       {
82923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82924       };
82925     } catch (...) {
82926       {
82927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82928       };
82929     }
82930   }
82931 }
82932
82933
82934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
82935   int jresult ;
82936   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82937   Dali::Property::Index result;
82938
82939   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82940   {
82941     try {
82942       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
82943     } catch (std::out_of_range& e) {
82944       {
82945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82946       };
82947     } catch (std::exception& e) {
82948       {
82949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82950       };
82951     } catch (...) {
82952       {
82953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82954       };
82955     }
82956   }
82957   jresult = result;
82958   return jresult;
82959 }
82960
82961
82962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
82963   void * jresult ;
82964   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82965   Dali::FrameBufferImage result;
82966
82967   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82968   {
82969     try {
82970       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
82971     } catch (std::out_of_range& e) {
82972       {
82973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82974       };
82975     } catch (std::exception& e) {
82976       {
82977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82978       };
82979     } catch (...) {
82980       {
82981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82982       };
82983     }
82984   }
82985   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
82986   return jresult;
82987 }
82988
82989
82990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
82991   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82992   Dali::Vector4 *arg2 = 0 ;
82993
82994   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82995   arg2 = (Dali::Vector4 *)jarg2;
82996   if (!arg2) {
82997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
82998     return ;
82999   }
83000   {
83001     try {
83002       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
83003     } catch (std::out_of_range& e) {
83004       {
83005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83006       };
83007     } catch (std::exception& e) {
83008       {
83009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83010       };
83011     } catch (...) {
83012       {
83013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83014       };
83015     }
83016   }
83017 }
83018
83019
83020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
83021   void * jresult ;
83022   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83023   Dali::Vector4 result;
83024
83025   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83026   {
83027     try {
83028       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
83029     } catch (std::out_of_range& e) {
83030       {
83031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83032       };
83033     } catch (std::exception& e) {
83034       {
83035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83036       };
83037     } catch (...) {
83038       {
83039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83040       };
83041     }
83042   }
83043   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
83044   return jresult;
83045 }
83046
83047
83048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
83049   void * jresult ;
83050   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83051   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
83052
83053   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83054   {
83055     try {
83056       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
83057     } catch (std::out_of_range& e) {
83058       {
83059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83060       };
83061     } catch (std::exception& e) {
83062       {
83063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83064       };
83065     } catch (...) {
83066       {
83067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83068       };
83069     }
83070   }
83071   jresult = (void *)result;
83072   return jresult;
83073 }
83074
83075
83076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
83077   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83078
83079   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83080   {
83081     try {
83082       delete arg1;
83083     } catch (std::out_of_range& e) {
83084       {
83085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83086       };
83087     } catch (std::exception& e) {
83088       {
83089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83090       };
83091     } catch (...) {
83092       {
83093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83094       };
83095     }
83096   }
83097 }
83098
83099
83100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
83101   unsigned int jresult ;
83102   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83103   unsigned int result;
83104
83105   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83106   {
83107     try {
83108       result = (unsigned int)(arg1)->GetNumberOfPages();
83109     } catch (std::out_of_range& e) {
83110       {
83111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83112       };
83113     } catch (std::exception& e) {
83114       {
83115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83116       };
83117     } catch (...) {
83118       {
83119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83120       };
83121     }
83122   }
83123   jresult = result;
83124   return jresult;
83125 }
83126
83127
83128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
83129   void * jresult ;
83130   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83131   unsigned int arg2 ;
83132   Dali::Texture result;
83133
83134   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83135   arg2 = (unsigned int)jarg2;
83136   {
83137     try {
83138       result = (arg1)->NewPage(arg2);
83139     } catch (std::out_of_range& e) {
83140       {
83141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83142       };
83143     } catch (std::exception& e) {
83144       {
83145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83146       };
83147     } catch (...) {
83148       {
83149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83150       };
83151     }
83152   }
83153   jresult = new Dali::Texture((const Dali::Texture &)result);
83154   return jresult;
83155 }
83156
83157
83158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
83159   int jresult ;
83160   int result;
83161
83162   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
83163   jresult = (int)result;
83164   return jresult;
83165 }
83166
83167
83168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
83169   int jresult ;
83170   int result;
83171
83172   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
83173   jresult = (int)result;
83174   return jresult;
83175 }
83176
83177
83178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
83179   int jresult ;
83180   int result;
83181
83182   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
83183   jresult = (int)result;
83184   return jresult;
83185 }
83186
83187
83188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
83189   void * jresult ;
83190   Dali::Toolkit::PageTurnView::Property *result = 0 ;
83191
83192   {
83193     try {
83194       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
83195     } catch (std::out_of_range& e) {
83196       {
83197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83198       };
83199     } catch (std::exception& e) {
83200       {
83201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83202       };
83203     } catch (...) {
83204       {
83205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83206       };
83207     }
83208   }
83209   jresult = (void *)result;
83210   return jresult;
83211 }
83212
83213
83214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
83215   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
83216
83217   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
83218   {
83219     try {
83220       delete arg1;
83221     } catch (std::out_of_range& e) {
83222       {
83223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83224       };
83225     } catch (std::exception& e) {
83226       {
83227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83228       };
83229     } catch (...) {
83230       {
83231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83232       };
83233     }
83234   }
83235 }
83236
83237
83238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
83239   void * jresult ;
83240   Dali::Toolkit::PageTurnView *result = 0 ;
83241
83242   {
83243     try {
83244       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
83245     } catch (std::out_of_range& e) {
83246       {
83247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83248       };
83249     } catch (std::exception& e) {
83250       {
83251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83252       };
83253     } catch (...) {
83254       {
83255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83256       };
83257     }
83258   }
83259   jresult = (void *)result;
83260   return jresult;
83261 }
83262
83263
83264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
83265   void * jresult ;
83266   Dali::Toolkit::PageTurnView *arg1 = 0 ;
83267   Dali::Toolkit::PageTurnView *result = 0 ;
83268
83269   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83270   if (!arg1) {
83271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83272     return 0;
83273   }
83274   {
83275     try {
83276       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
83277     } catch (std::out_of_range& e) {
83278       {
83279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83280       };
83281     } catch (std::exception& e) {
83282       {
83283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83284       };
83285     } catch (...) {
83286       {
83287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83288       };
83289     }
83290   }
83291   jresult = (void *)result;
83292   return jresult;
83293 }
83294
83295
83296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
83297   void * jresult ;
83298   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83299   Dali::Toolkit::PageTurnView *arg2 = 0 ;
83300   Dali::Toolkit::PageTurnView *result = 0 ;
83301
83302   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83303   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
83304   if (!arg2) {
83305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83306     return 0;
83307   }
83308   {
83309     try {
83310       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
83311     } catch (std::out_of_range& e) {
83312       {
83313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83314       };
83315     } catch (std::exception& e) {
83316       {
83317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83318       };
83319     } catch (...) {
83320       {
83321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83322       };
83323     }
83324   }
83325   jresult = (void *)result;
83326   return jresult;
83327 }
83328
83329
83330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
83331   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83332
83333   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83334   {
83335     try {
83336       delete arg1;
83337     } catch (std::out_of_range& e) {
83338       {
83339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83340       };
83341     } catch (std::exception& e) {
83342       {
83343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83344       };
83345     } catch (...) {
83346       {
83347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83348       };
83349     }
83350   }
83351 }
83352
83353
83354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
83355   void * jresult ;
83356   Dali::BaseHandle arg1 ;
83357   Dali::BaseHandle *argp1 ;
83358   Dali::Toolkit::PageTurnView result;
83359
83360   argp1 = (Dali::BaseHandle *)jarg1;
83361   if (!argp1) {
83362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83363     return 0;
83364   }
83365   arg1 = *argp1;
83366   {
83367     try {
83368       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
83369     } catch (std::out_of_range& e) {
83370       {
83371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83372       };
83373     } catch (std::exception& e) {
83374       {
83375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83376       };
83377     } catch (...) {
83378       {
83379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83380       };
83381     }
83382   }
83383   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
83384   return jresult;
83385 }
83386
83387
83388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
83389   void * jresult ;
83390   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83391   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83392
83393   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83394   {
83395     try {
83396       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
83397     } catch (std::out_of_range& e) {
83398       {
83399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83400       };
83401     } catch (std::exception& e) {
83402       {
83403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83404       };
83405     } catch (...) {
83406       {
83407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83408       };
83409     }
83410   }
83411   jresult = (void *)result;
83412   return jresult;
83413 }
83414
83415
83416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
83417   void * jresult ;
83418   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83419   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83420
83421   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83422   {
83423     try {
83424       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
83425     } catch (std::out_of_range& e) {
83426       {
83427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83428       };
83429     } catch (std::exception& e) {
83430       {
83431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83432       };
83433     } catch (...) {
83434       {
83435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83436       };
83437     }
83438   }
83439   jresult = (void *)result;
83440   return jresult;
83441 }
83442
83443
83444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
83445   void * jresult ;
83446   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83447   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83448
83449   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83450   {
83451     try {
83452       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
83453     } catch (std::out_of_range& e) {
83454       {
83455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83456       };
83457     } catch (std::exception& e) {
83458       {
83459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83460       };
83461     } catch (...) {
83462       {
83463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83464       };
83465     }
83466   }
83467   jresult = (void *)result;
83468   return jresult;
83469 }
83470
83471
83472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
83473   void * jresult ;
83474   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83475   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83476
83477   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83478   {
83479     try {
83480       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
83481     } catch (std::out_of_range& e) {
83482       {
83483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83484       };
83485     } catch (std::exception& e) {
83486       {
83487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83488       };
83489     } catch (...) {
83490       {
83491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83492       };
83493     }
83494   }
83495   jresult = (void *)result;
83496   return jresult;
83497 }
83498
83499
83500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
83501   void * jresult ;
83502   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83503
83504   {
83505     try {
83506       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
83507     } catch (std::out_of_range& e) {
83508       {
83509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83510       };
83511     } catch (std::exception& e) {
83512       {
83513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83514       };
83515     } catch (...) {
83516       {
83517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83518       };
83519     }
83520   }
83521   jresult = (void *)result;
83522   return jresult;
83523 }
83524
83525
83526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
83527   void * jresult ;
83528   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
83529   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83530
83531   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83532   if (!arg1) {
83533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83534     return 0;
83535   }
83536   {
83537     try {
83538       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
83539     } catch (std::out_of_range& e) {
83540       {
83541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83542       };
83543     } catch (std::exception& e) {
83544       {
83545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83546       };
83547     } catch (...) {
83548       {
83549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83550       };
83551     }
83552   }
83553   jresult = (void *)result;
83554   return jresult;
83555 }
83556
83557
83558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
83559   void * jresult ;
83560   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83561   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
83562   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83563
83564   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83565   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
83566   if (!arg2) {
83567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83568     return 0;
83569   }
83570   {
83571     try {
83572       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
83573     } catch (std::out_of_range& e) {
83574       {
83575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83576       };
83577     } catch (std::exception& e) {
83578       {
83579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83580       };
83581     } catch (...) {
83582       {
83583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83584       };
83585     }
83586   }
83587   jresult = (void *)result;
83588   return jresult;
83589 }
83590
83591
83592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
83593   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83594
83595   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83596   {
83597     try {
83598       delete arg1;
83599     } catch (std::out_of_range& e) {
83600       {
83601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83602       };
83603     } catch (std::exception& e) {
83604       {
83605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83606       };
83607     } catch (...) {
83608       {
83609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83610       };
83611     }
83612   }
83613 }
83614
83615
83616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
83617   void * jresult ;
83618   Dali::Toolkit::PageFactory *arg1 = 0 ;
83619   Dali::Vector2 *arg2 = 0 ;
83620   Dali::Toolkit::PageTurnLandscapeView result;
83621
83622   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83623   if (!arg1) {
83624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83625     return 0;
83626   }
83627   arg2 = (Dali::Vector2 *)jarg2;
83628   if (!arg2) {
83629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83630     return 0;
83631   }
83632   {
83633     try {
83634       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
83635     } catch (std::out_of_range& e) {
83636       {
83637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83638       };
83639     } catch (std::exception& e) {
83640       {
83641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83642       };
83643     } catch (...) {
83644       {
83645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83646       };
83647     }
83648   }
83649   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83650   return jresult;
83651 }
83652
83653
83654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
83655   void * jresult ;
83656   Dali::BaseHandle arg1 ;
83657   Dali::BaseHandle *argp1 ;
83658   Dali::Toolkit::PageTurnLandscapeView result;
83659
83660   argp1 = (Dali::BaseHandle *)jarg1;
83661   if (!argp1) {
83662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83663     return 0;
83664   }
83665   arg1 = *argp1;
83666   {
83667     try {
83668       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
83669     } catch (std::out_of_range& e) {
83670       {
83671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83672       };
83673     } catch (std::exception& e) {
83674       {
83675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83676       };
83677     } catch (...) {
83678       {
83679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83680       };
83681     }
83682   }
83683   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83684   return jresult;
83685 }
83686
83687
83688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
83689   void * jresult ;
83690   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83691
83692   {
83693     try {
83694       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
83695     } catch (std::out_of_range& e) {
83696       {
83697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83698       };
83699     } catch (std::exception& e) {
83700       {
83701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83702       };
83703     } catch (...) {
83704       {
83705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83706       };
83707     }
83708   }
83709   jresult = (void *)result;
83710   return jresult;
83711 }
83712
83713
83714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
83715   void * jresult ;
83716   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
83717   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83718
83719   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83720   if (!arg1) {
83721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83722     return 0;
83723   }
83724   {
83725     try {
83726       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
83727     } catch (std::out_of_range& e) {
83728       {
83729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83730       };
83731     } catch (std::exception& e) {
83732       {
83733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83734       };
83735     } catch (...) {
83736       {
83737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83738       };
83739     }
83740   }
83741   jresult = (void *)result;
83742   return jresult;
83743 }
83744
83745
83746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
83747   void * jresult ;
83748   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83749   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
83750   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83751
83752   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83753   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
83754   if (!arg2) {
83755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83756     return 0;
83757   }
83758   {
83759     try {
83760       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
83761     } catch (std::out_of_range& e) {
83762       {
83763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83764       };
83765     } catch (std::exception& e) {
83766       {
83767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83768       };
83769     } catch (...) {
83770       {
83771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83772       };
83773     }
83774   }
83775   jresult = (void *)result;
83776   return jresult;
83777 }
83778
83779
83780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
83781   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83782
83783   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83784   {
83785     try {
83786       delete arg1;
83787     } catch (std::out_of_range& e) {
83788       {
83789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83790       };
83791     } catch (std::exception& e) {
83792       {
83793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83794       };
83795     } catch (...) {
83796       {
83797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83798       };
83799     }
83800   }
83801 }
83802
83803
83804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
83805   void * jresult ;
83806   Dali::Toolkit::PageFactory *arg1 = 0 ;
83807   Dali::Vector2 *arg2 = 0 ;
83808   Dali::Toolkit::PageTurnPortraitView result;
83809
83810   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83811   if (!arg1) {
83812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83813     return 0;
83814   }
83815   arg2 = (Dali::Vector2 *)jarg2;
83816   if (!arg2) {
83817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83818     return 0;
83819   }
83820   {
83821     try {
83822       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
83823     } catch (std::out_of_range& e) {
83824       {
83825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83826       };
83827     } catch (std::exception& e) {
83828       {
83829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83830       };
83831     } catch (...) {
83832       {
83833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83834       };
83835     }
83836   }
83837   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
83838   return jresult;
83839 }
83840
83841
83842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
83843   void * jresult ;
83844   Dali::BaseHandle arg1 ;
83845   Dali::BaseHandle *argp1 ;
83846   Dali::Toolkit::PageTurnPortraitView result;
83847
83848   argp1 = (Dali::BaseHandle *)jarg1;
83849   if (!argp1) {
83850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83851     return 0;
83852   }
83853   arg1 = *argp1;
83854   {
83855     try {
83856       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
83857     } catch (std::out_of_range& e) {
83858       {
83859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83860       };
83861     } catch (std::exception& e) {
83862       {
83863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83864       };
83865     } catch (...) {
83866       {
83867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83868       };
83869     }
83870   }
83871   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
83872   return jresult;
83873 }
83874
83875
83876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
83877   int jresult ;
83878   int result;
83879
83880   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
83881   jresult = (int)result;
83882   return jresult;
83883 }
83884
83885
83886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
83887   int jresult ;
83888   int result;
83889
83890   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
83891   jresult = (int)result;
83892   return jresult;
83893 }
83894
83895
83896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
83897   int jresult ;
83898   int result;
83899
83900   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
83901   jresult = (int)result;
83902   return jresult;
83903 }
83904
83905
83906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
83907   void * jresult ;
83908   Dali::Toolkit::ToggleButton::Property *result = 0 ;
83909
83910   {
83911     try {
83912       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
83913     } catch (std::out_of_range& e) {
83914       {
83915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83916       };
83917     } catch (std::exception& e) {
83918       {
83919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83920       };
83921     } catch (...) {
83922       {
83923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83924       };
83925     }
83926   }
83927   jresult = (void *)result;
83928   return jresult;
83929 }
83930
83931
83932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
83933   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
83934
83935   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
83936   {
83937     try {
83938       delete arg1;
83939     } catch (std::out_of_range& e) {
83940       {
83941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83942       };
83943     } catch (std::exception& e) {
83944       {
83945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83946       };
83947     } catch (...) {
83948       {
83949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83950       };
83951     }
83952   }
83953 }
83954
83955
83956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
83957   void * jresult ;
83958   Dali::Toolkit::ToggleButton *result = 0 ;
83959
83960   {
83961     try {
83962       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
83963     } catch (std::out_of_range& e) {
83964       {
83965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83966       };
83967     } catch (std::exception& e) {
83968       {
83969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83970       };
83971     } catch (...) {
83972       {
83973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83974       };
83975     }
83976   }
83977   jresult = (void *)result;
83978   return jresult;
83979 }
83980
83981
83982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
83983   void * jresult ;
83984   Dali::Toolkit::ToggleButton *arg1 = 0 ;
83985   Dali::Toolkit::ToggleButton *result = 0 ;
83986
83987   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
83988   if (!arg1) {
83989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
83990     return 0;
83991   }
83992   {
83993     try {
83994       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
83995     } catch (std::out_of_range& e) {
83996       {
83997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83998       };
83999     } catch (std::exception& e) {
84000       {
84001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84002       };
84003     } catch (...) {
84004       {
84005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84006       };
84007     }
84008   }
84009   jresult = (void *)result;
84010   return jresult;
84011 }
84012
84013
84014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
84015   void * jresult ;
84016   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84017   Dali::Toolkit::ToggleButton *arg2 = 0 ;
84018   Dali::Toolkit::ToggleButton *result = 0 ;
84019
84020   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84021   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
84022   if (!arg2) {
84023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84024     return 0;
84025   }
84026   {
84027     try {
84028       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
84029     } catch (std::out_of_range& e) {
84030       {
84031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84032       };
84033     } catch (std::exception& e) {
84034       {
84035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84036       };
84037     } catch (...) {
84038       {
84039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84040       };
84041     }
84042   }
84043   jresult = (void *)result;
84044   return jresult;
84045 }
84046
84047
84048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
84049   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84050
84051   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84052   {
84053     try {
84054       delete arg1;
84055     } catch (std::out_of_range& e) {
84056       {
84057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84058       };
84059     } catch (std::exception& e) {
84060       {
84061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84062       };
84063     } catch (...) {
84064       {
84065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84066       };
84067     }
84068   }
84069 }
84070
84071
84072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
84073   void * jresult ;
84074   Dali::Toolkit::ToggleButton result;
84075
84076   {
84077     try {
84078       result = Dali::Toolkit::ToggleButton::New();
84079     } catch (std::out_of_range& e) {
84080       {
84081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84082       };
84083     } catch (std::exception& e) {
84084       {
84085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84086       };
84087     } catch (...) {
84088       {
84089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84090       };
84091     }
84092   }
84093   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84094   return jresult;
84095 }
84096
84097
84098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
84099   void * jresult ;
84100   Dali::BaseHandle arg1 ;
84101   Dali::BaseHandle *argp1 ;
84102   Dali::Toolkit::ToggleButton result;
84103
84104   argp1 = (Dali::BaseHandle *)jarg1;
84105   if (!argp1) {
84106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84107     return 0;
84108   }
84109   arg1 = *argp1;
84110   {
84111     try {
84112       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
84113     } catch (std::out_of_range& e) {
84114       {
84115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84116       };
84117     } catch (std::exception& e) {
84118       {
84119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84120       };
84121     } catch (...) {
84122       {
84123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84124       };
84125     }
84126   }
84127   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84128   return jresult;
84129 }
84130
84131
84132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
84133   void * jresult ;
84134   Dali::Toolkit::Visual::Base *result = 0 ;
84135
84136   {
84137     try {
84138       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
84139     } catch (std::out_of_range& e) {
84140       {
84141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84142       };
84143     } catch (std::exception& e) {
84144       {
84145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84146       };
84147     } catch (...) {
84148       {
84149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84150       };
84151     }
84152   }
84153   jresult = (void *)result;
84154   return jresult;
84155 }
84156
84157
84158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
84159   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84160
84161   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84162   {
84163     try {
84164       delete arg1;
84165     } catch (std::out_of_range& e) {
84166       {
84167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84168       };
84169     } catch (std::exception& e) {
84170       {
84171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84172       };
84173     } catch (...) {
84174       {
84175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84176       };
84177     }
84178   }
84179 }
84180
84181
84182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
84183   void * jresult ;
84184   Dali::Toolkit::Visual::Base *arg1 = 0 ;
84185   Dali::Toolkit::Visual::Base *result = 0 ;
84186
84187   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84188   if (!arg1) {
84189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84190     return 0;
84191   }
84192   {
84193     try {
84194       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base 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 (...) {
84204       {
84205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84206       };
84207     }
84208   }
84209   jresult = (void *)result;
84210   return jresult;
84211 }
84212
84213
84214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
84215   void * jresult ;
84216   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84217   Dali::Toolkit::Visual::Base *arg2 = 0 ;
84218   Dali::Toolkit::Visual::Base *result = 0 ;
84219
84220   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84221   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
84222   if (!arg2) {
84223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84224     return 0;
84225   }
84226   {
84227     try {
84228       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
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 (...) {
84238       {
84239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84240       };
84241     }
84242   }
84243   jresult = (void *)result;
84244   return jresult;
84245 }
84246
84247
84248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
84249   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84250   std::string *arg2 = 0 ;
84251
84252   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84253   if (!jarg2) {
84254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84255     return ;
84256   }
84257   std::string arg2_str(jarg2);
84258   arg2 = &arg2_str;
84259   {
84260     try {
84261       (arg1)->SetName((std::string const &)*arg2);
84262     } catch (std::out_of_range& e) {
84263       {
84264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84265       };
84266     } catch (std::exception& e) {
84267       {
84268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84269       };
84270     } catch (...) {
84271       {
84272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84273       };
84274     }
84275   }
84276
84277   //argout typemap for const std::string&
84278
84279 }
84280
84281
84282 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
84283   char * jresult ;
84284   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84285   std::string *result = 0 ;
84286
84287   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84288   {
84289     try {
84290       result = (std::string *) &(arg1)->GetName();
84291     } catch (std::out_of_range& e) {
84292       {
84293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84294       };
84295     } catch (std::exception& e) {
84296       {
84297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84298       };
84299     } catch (...) {
84300       {
84301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84302       };
84303     }
84304   }
84305   jresult = SWIG_csharp_string_callback(result->c_str());
84306   return jresult;
84307 }
84308
84309
84310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84311   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84312   Dali::Property::Map *arg2 = 0 ;
84313   Dali::Size arg3 ;
84314   Dali::Size *argp3 ;
84315
84316   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84317   arg2 = (Dali::Property::Map *)jarg2;
84318   if (!arg2) {
84319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84320     return ;
84321   }
84322   argp3 = (Dali::Size *)jarg3;
84323   if (!argp3) {
84324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84325     return ;
84326   }
84327   arg3 = *argp3;
84328   {
84329     try {
84330       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84331     } catch (std::out_of_range& e) {
84332       {
84333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84334       };
84335     } catch (std::exception& e) {
84336       {
84337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84338       };
84339     } catch (...) {
84340       {
84341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84342       };
84343     }
84344   }
84345 }
84346
84347
84348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84349   float jresult ;
84350   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84351   float arg2 ;
84352   float result;
84353
84354   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84355   arg2 = (float)jarg2;
84356   {
84357     try {
84358       result = (float)(arg1)->GetHeightForWidth(arg2);
84359     } catch (std::out_of_range& e) {
84360       {
84361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84362       };
84363     } catch (std::exception& e) {
84364       {
84365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84366       };
84367     } catch (...) {
84368       {
84369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84370       };
84371     }
84372   }
84373   jresult = result;
84374   return jresult;
84375 }
84376
84377
84378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
84379   float jresult ;
84380   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84381   float arg2 ;
84382   float result;
84383
84384   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84385   arg2 = (float)jarg2;
84386   {
84387     try {
84388       result = (float)(arg1)->GetWidthForHeight(arg2);
84389     } catch (std::out_of_range& e) {
84390       {
84391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84392       };
84393     } catch (std::exception& e) {
84394       {
84395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84396       };
84397     } catch (...) {
84398       {
84399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84400       };
84401     }
84402   }
84403   jresult = result;
84404   return jresult;
84405 }
84406
84407
84408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
84409   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84410   Dali::Vector2 *arg2 = 0 ;
84411
84412   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84413   arg2 = (Dali::Vector2 *)jarg2;
84414   if (!arg2) {
84415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
84416     return ;
84417   }
84418   {
84419     try {
84420       (arg1)->GetNaturalSize(*arg2);
84421     } catch (std::out_of_range& e) {
84422       {
84423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84424       };
84425     } catch (std::exception& e) {
84426       {
84427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84428       };
84429     } catch (...) {
84430       {
84431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84432       };
84433     }
84434   }
84435 }
84436
84437
84438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
84439   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84440   float arg2 ;
84441
84442   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84443   arg2 = (float)jarg2;
84444   {
84445     try {
84446       (arg1)->SetDepthIndex(arg2);
84447     } catch (std::out_of_range& e) {
84448       {
84449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84450       };
84451     } catch (std::exception& e) {
84452       {
84453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84454       };
84455     } catch (...) {
84456       {
84457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84458       };
84459     }
84460   }
84461 }
84462
84463
84464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
84465   float jresult ;
84466   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84467   float result;
84468
84469   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84470   {
84471     try {
84472       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
84473     } catch (std::out_of_range& e) {
84474       {
84475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84476       };
84477     } catch (std::exception& e) {
84478       {
84479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84480       };
84481     } catch (...) {
84482       {
84483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84484       };
84485     }
84486   }
84487   jresult = result;
84488   return jresult;
84489 }
84490
84491
84492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
84493   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84494   Dali::Property::Map *arg2 = 0 ;
84495
84496   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84497   arg2 = (Dali::Property::Map *)jarg2;
84498   if (!arg2) {
84499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
84500     return ;
84501   }
84502   {
84503     try {
84504       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
84505     } catch (std::out_of_range& e) {
84506       {
84507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84508       };
84509     } catch (std::exception& e) {
84510       {
84511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84512       };
84513     } catch (...) {
84514       {
84515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84516       };
84517     }
84518   }
84519 }
84520
84521
84522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
84523   void * jresult ;
84524   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
84525   Dali::Toolkit::Visual::Base *result = 0 ;
84526
84527   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
84528   {
84529     try {
84530       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
84531     } catch (std::out_of_range& e) {
84532       {
84533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84534       };
84535     } catch (std::exception& e) {
84536       {
84537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84538       };
84539     } catch (...) {
84540       {
84541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84542       };
84543     }
84544   }
84545   jresult = (void *)result;
84546   return jresult;
84547 }
84548
84549
84550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
84551   void * jresult ;
84552   Dali::Toolkit::VisualFactory result;
84553
84554   {
84555     try {
84556       result = Dali::Toolkit::VisualFactory::Get();
84557     } catch (std::out_of_range& e) {
84558       {
84559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84560       };
84561     } catch (std::exception& e) {
84562       {
84563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84564       };
84565     } catch (...) {
84566       {
84567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84568       };
84569     }
84570   }
84571   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
84572   return jresult;
84573 }
84574
84575
84576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
84577   void * jresult ;
84578   Dali::Toolkit::VisualFactory *result = 0 ;
84579
84580   {
84581     try {
84582       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
84583     } catch (std::out_of_range& e) {
84584       {
84585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84586       };
84587     } catch (std::exception& e) {
84588       {
84589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84590       };
84591     } catch (...) {
84592       {
84593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84594       };
84595     }
84596   }
84597   jresult = (void *)result;
84598   return jresult;
84599 }
84600
84601
84602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
84603   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84604
84605   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84606   {
84607     try {
84608       delete arg1;
84609     } catch (std::out_of_range& e) {
84610       {
84611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84612       };
84613     } catch (std::exception& e) {
84614       {
84615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84616       };
84617     } catch (...) {
84618       {
84619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84620       };
84621     }
84622   }
84623 }
84624
84625
84626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
84627   void * jresult ;
84628   Dali::Toolkit::VisualFactory *arg1 = 0 ;
84629   Dali::Toolkit::VisualFactory *result = 0 ;
84630
84631   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84632   if (!arg1) {
84633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84634     return 0;
84635   }
84636   {
84637     try {
84638       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
84639     } catch (std::out_of_range& e) {
84640       {
84641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84642       };
84643     } catch (std::exception& e) {
84644       {
84645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84646       };
84647     } catch (...) {
84648       {
84649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84650       };
84651     }
84652   }
84653   jresult = (void *)result;
84654   return jresult;
84655 }
84656
84657
84658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
84659   void * jresult ;
84660   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84661   Dali::Toolkit::VisualFactory *arg2 = 0 ;
84662   Dali::Toolkit::VisualFactory *result = 0 ;
84663
84664   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84665   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
84666   if (!arg2) {
84667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84668     return 0;
84669   }
84670   {
84671     try {
84672       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
84673     } catch (std::out_of_range& e) {
84674       {
84675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84676       };
84677     } catch (std::exception& e) {
84678       {
84679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84680       };
84681     } catch (...) {
84682       {
84683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84684       };
84685     }
84686   }
84687   jresult = (void *)result;
84688   return jresult;
84689 }
84690
84691
84692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
84693   void * jresult ;
84694   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84695   Dali::Property::Map *arg2 = 0 ;
84696   Dali::Toolkit::Visual::Base result;
84697
84698   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84699   arg2 = (Dali::Property::Map *)jarg2;
84700   if (!arg2) {
84701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84702     return 0;
84703   }
84704   {
84705     try {
84706       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
84707     } catch (std::out_of_range& e) {
84708       {
84709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84710       };
84711     } catch (std::exception& e) {
84712       {
84713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84714       };
84715     } catch (...) {
84716       {
84717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84718       };
84719     }
84720   }
84721   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84722   return jresult;
84723 }
84724
84725
84726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
84727   void * jresult ;
84728   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84729   Dali::Image *arg2 = 0 ;
84730   Dali::Toolkit::Visual::Base result;
84731
84732   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84733   arg2 = (Dali::Image *)jarg2;
84734   if (!arg2) {
84735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
84736     return 0;
84737   }
84738   {
84739     try {
84740       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
84741     } catch (std::out_of_range& e) {
84742       {
84743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84744       };
84745     } catch (std::exception& e) {
84746       {
84747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84748       };
84749     } catch (...) {
84750       {
84751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84752       };
84753     }
84754   }
84755   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84756   return jresult;
84757 }
84758
84759
84760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
84761   void * jresult ;
84762   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84763   std::string *arg2 = 0 ;
84764   Dali::ImageDimensions arg3 ;
84765   Dali::ImageDimensions *argp3 ;
84766   Dali::Toolkit::Visual::Base result;
84767
84768   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84769   if (!jarg2) {
84770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84771     return 0;
84772   }
84773   std::string arg2_str(jarg2);
84774   arg2 = &arg2_str;
84775   argp3 = (Dali::ImageDimensions *)jarg3;
84776   if (!argp3) {
84777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
84778     return 0;
84779   }
84780   arg3 = *argp3;
84781   {
84782     try {
84783       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
84784     } catch (std::out_of_range& e) {
84785       {
84786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84787       };
84788     } catch (std::exception& e) {
84789       {
84790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84791       };
84792     } catch (...) {
84793       {
84794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84795       };
84796     }
84797   }
84798   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84799
84800   //argout typemap for const std::string&
84801
84802   return jresult;
84803 }
84804
84805
84806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
84807   void * jresult ;
84808   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84809
84810   {
84811     try {
84812       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
84813     } catch (std::out_of_range& e) {
84814       {
84815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84816       };
84817     } catch (std::exception& e) {
84818       {
84819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84820       };
84821     } catch (...) {
84822       {
84823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84824       };
84825     }
84826   }
84827   jresult = (void *)result;
84828   return jresult;
84829 }
84830
84831
84832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
84833   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84834
84835   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84836   {
84837     try {
84838       delete arg1;
84839     } catch (std::out_of_range& e) {
84840       {
84841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84842       };
84843     } catch (std::exception& e) {
84844       {
84845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84846       };
84847     } catch (...) {
84848       {
84849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84850       };
84851     }
84852   }
84853 }
84854
84855
84856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
84857   void * jresult ;
84858   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
84859   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84860
84861   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84862   if (!arg1) {
84863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
84864     return 0;
84865   }
84866   {
84867     try {
84868       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
84869     } catch (std::out_of_range& e) {
84870       {
84871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84872       };
84873     } catch (std::exception& e) {
84874       {
84875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84876       };
84877     } catch (...) {
84878       {
84879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84880       };
84881     }
84882   }
84883   jresult = (void *)result;
84884   return jresult;
84885 }
84886
84887
84888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
84889   void * jresult ;
84890   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84891   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
84892   Dali::Toolkit::AsyncImageLoader *result = 0 ;
84893
84894   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84895   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
84896   if (!arg2) {
84897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
84898     return 0;
84899   }
84900   {
84901     try {
84902       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
84903     } catch (std::out_of_range& e) {
84904       {
84905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84906       };
84907     } catch (std::exception& e) {
84908       {
84909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84910       };
84911     } catch (...) {
84912       {
84913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84914       };
84915     }
84916   }
84917   jresult = (void *)result;
84918   return jresult;
84919 }
84920
84921
84922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
84923   void * jresult ;
84924   Dali::Toolkit::AsyncImageLoader result;
84925
84926   {
84927     try {
84928       result = Dali::Toolkit::AsyncImageLoader::New();
84929     } catch (std::out_of_range& e) {
84930       {
84931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84932       };
84933     } catch (std::exception& e) {
84934       {
84935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84936       };
84937     } catch (...) {
84938       {
84939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84940       };
84941     }
84942   }
84943   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
84944   return jresult;
84945 }
84946
84947
84948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
84949   void * jresult ;
84950   Dali::BaseHandle arg1 ;
84951   Dali::BaseHandle *argp1 ;
84952   Dali::Toolkit::AsyncImageLoader result;
84953
84954   argp1 = (Dali::BaseHandle *)jarg1;
84955   if (!argp1) {
84956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84957     return 0;
84958   }
84959   arg1 = *argp1;
84960   {
84961     try {
84962       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
84963     } catch (std::out_of_range& e) {
84964       {
84965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84966       };
84967     } catch (std::exception& e) {
84968       {
84969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84970       };
84971     } catch (...) {
84972       {
84973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84974       };
84975     }
84976   }
84977   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
84978   return jresult;
84979 }
84980
84981
84982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
84983   unsigned int jresult ;
84984   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
84985   std::string *arg2 = 0 ;
84986   uint32_t result;
84987
84988   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
84989   if (!jarg2) {
84990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84991     return 0;
84992   }
84993   std::string arg2_str(jarg2);
84994   arg2 = &arg2_str;
84995   {
84996     try {
84997       result = (arg1)->Load((std::string const &)*arg2);
84998     } catch (std::out_of_range& e) {
84999       {
85000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85001       };
85002     } catch (std::exception& e) {
85003       {
85004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85005       };
85006     } catch (...) {
85007       {
85008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85009       };
85010     }
85011   }
85012   jresult = result;
85013
85014   //argout typemap for const std::string&
85015
85016   return jresult;
85017 }
85018
85019
85020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
85021   unsigned int jresult ;
85022   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85023   std::string *arg2 = 0 ;
85024   Dali::ImageDimensions arg3 ;
85025   Dali::ImageDimensions *argp3 ;
85026   uint32_t result;
85027
85028   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85029   if (!jarg2) {
85030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85031     return 0;
85032   }
85033   std::string arg2_str(jarg2);
85034   arg2 = &arg2_str;
85035   argp3 = (Dali::ImageDimensions *)jarg3;
85036   if (!argp3) {
85037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85038     return 0;
85039   }
85040   arg3 = *argp3;
85041   {
85042     try {
85043       result = (arg1)->Load((std::string const &)*arg2,arg3);
85044     } catch (std::out_of_range& e) {
85045       {
85046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85047       };
85048     } catch (std::exception& e) {
85049       {
85050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85051       };
85052     } catch (...) {
85053       {
85054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85055       };
85056     }
85057   }
85058   jresult = result;
85059
85060   //argout typemap for const std::string&
85061
85062   return jresult;
85063 }
85064
85065
85066 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
85067   unsigned int jresult ;
85068   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85069   std::string *arg2 = 0 ;
85070   Dali::ImageDimensions arg3 ;
85071   Dali::FittingMode::Type arg4 ;
85072   Dali::SamplingMode::Type arg5 ;
85073   bool arg6 ;
85074   Dali::ImageDimensions *argp3 ;
85075   uint32_t result;
85076
85077   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85078   if (!jarg2) {
85079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85080     return 0;
85081   }
85082   std::string arg2_str(jarg2);
85083   arg2 = &arg2_str;
85084   argp3 = (Dali::ImageDimensions *)jarg3;
85085   if (!argp3) {
85086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85087     return 0;
85088   }
85089   arg3 = *argp3;
85090   arg4 = (Dali::FittingMode::Type)jarg4;
85091   arg5 = (Dali::SamplingMode::Type)jarg5;
85092   arg6 = jarg6 ? true : false;
85093   {
85094     try {
85095       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
85096     } catch (std::out_of_range& e) {
85097       {
85098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85099       };
85100     } catch (std::exception& e) {
85101       {
85102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85103       };
85104     } catch (...) {
85105       {
85106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85107       };
85108     }
85109   }
85110   jresult = result;
85111
85112   //argout typemap for const std::string&
85113
85114   return jresult;
85115 }
85116
85117
85118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
85119   unsigned int jresult ;
85120   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85121   uint32_t arg2 ;
85122   bool result;
85123
85124   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85125   arg2 = (uint32_t)jarg2;
85126   {
85127     try {
85128       result = (bool)(arg1)->Cancel(arg2);
85129     } catch (std::out_of_range& e) {
85130       {
85131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85132       };
85133     } catch (std::exception& e) {
85134       {
85135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85136       };
85137     } catch (...) {
85138       {
85139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85140       };
85141     }
85142   }
85143   jresult = result;
85144   return jresult;
85145 }
85146
85147
85148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
85149   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85150
85151   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85152   {
85153     try {
85154       (arg1)->CancelAll();
85155     } catch (std::out_of_range& e) {
85156       {
85157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85158       };
85159     } catch (std::exception& e) {
85160       {
85161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85162       };
85163     } catch (...) {
85164       {
85165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85166       };
85167     }
85168   }
85169 }
85170
85171
85172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
85173   void * jresult ;
85174   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85175   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
85176
85177   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85178   {
85179     try {
85180       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
85181     } catch (std::out_of_range& e) {
85182       {
85183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85184       };
85185     } catch (std::exception& e) {
85186       {
85187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85188       };
85189     } catch (...) {
85190       {
85191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85192       };
85193     }
85194   }
85195   jresult = (void *)result;
85196   return jresult;
85197 }
85198
85199
85200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
85201   void * jresult ;
85202   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
85203   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85204
85205   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
85206   {
85207     try {
85208       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
85209     } catch (std::out_of_range& e) {
85210       {
85211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85212       };
85213     } catch (std::exception& e) {
85214       {
85215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85216       };
85217     } catch (...) {
85218       {
85219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85220       };
85221     }
85222   }
85223   jresult = (void *)result;
85224   return jresult;
85225 }
85226
85227
85228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
85229   void * jresult ;
85230   std::string *arg1 = 0 ;
85231   Dali::PixelData result;
85232
85233   if (!jarg1) {
85234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85235     return 0;
85236   }
85237   std::string arg1_str(jarg1);
85238   arg1 = &arg1_str;
85239   {
85240     try {
85241       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
85242     } catch (std::out_of_range& e) {
85243       {
85244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85245       };
85246     } catch (std::exception& e) {
85247       {
85248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85249       };
85250     } catch (...) {
85251       {
85252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85253       };
85254     }
85255   }
85256   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85257
85258   //argout typemap for const std::string&
85259
85260   return jresult;
85261 }
85262
85263
85264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85265   void * jresult ;
85266   std::string *arg1 = 0 ;
85267   Dali::ImageDimensions arg2 ;
85268   Dali::ImageDimensions *argp2 ;
85269   Dali::PixelData result;
85270
85271   if (!jarg1) {
85272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85273     return 0;
85274   }
85275   std::string arg1_str(jarg1);
85276   arg1 = &arg1_str;
85277   argp2 = (Dali::ImageDimensions *)jarg2;
85278   if (!argp2) {
85279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85280     return 0;
85281   }
85282   arg2 = *argp2;
85283   {
85284     try {
85285       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85286     } catch (std::out_of_range& e) {
85287       {
85288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85289       };
85290     } catch (std::exception& e) {
85291       {
85292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85293       };
85294     } catch (...) {
85295       {
85296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85297       };
85298     }
85299   }
85300   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85301
85302   //argout typemap for const std::string&
85303
85304   return jresult;
85305 }
85306
85307
85308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85309   void * jresult ;
85310   std::string *arg1 = 0 ;
85311   Dali::ImageDimensions arg2 ;
85312   Dali::FittingMode::Type arg3 ;
85313   Dali::SamplingMode::Type arg4 ;
85314   bool arg5 ;
85315   Dali::ImageDimensions *argp2 ;
85316   Dali::PixelData result;
85317
85318   if (!jarg1) {
85319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85320     return 0;
85321   }
85322   std::string arg1_str(jarg1);
85323   arg1 = &arg1_str;
85324   argp2 = (Dali::ImageDimensions *)jarg2;
85325   if (!argp2) {
85326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85327     return 0;
85328   }
85329   arg2 = *argp2;
85330   arg3 = (Dali::FittingMode::Type)jarg3;
85331   arg4 = (Dali::SamplingMode::Type)jarg4;
85332   arg5 = jarg5 ? true : false;
85333   {
85334     try {
85335       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85336     } catch (std::out_of_range& e) {
85337       {
85338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85339       };
85340     } catch (std::exception& e) {
85341       {
85342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85343       };
85344     } catch (...) {
85345       {
85346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85347       };
85348     }
85349   }
85350   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85351
85352   //argout typemap for const std::string&
85353
85354   return jresult;
85355 }
85356
85357
85358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
85359   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85360
85361   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85362   {
85363     try {
85364       delete arg1;
85365     } catch (std::out_of_range& e) {
85366       {
85367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85368       };
85369     } catch (std::exception& e) {
85370       {
85371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85372       };
85373     } catch (...) {
85374       {
85375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85376       };
85377     }
85378   }
85379 }
85380
85381
85382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
85383   void * jresult ;
85384   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85385   Dali::Actor arg2 ;
85386   Dali::Actor arg3 ;
85387   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
85388   Dali::Actor *argp2 ;
85389   Dali::Actor *argp3 ;
85390   Dali::Actor result;
85391
85392   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85393   argp2 = (Dali::Actor *)jarg2;
85394   if (!argp2) {
85395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85396     return 0;
85397   }
85398   arg2 = *argp2;
85399   argp3 = (Dali::Actor *)jarg3;
85400   if (!argp3) {
85401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85402     return 0;
85403   }
85404   arg3 = *argp3;
85405   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
85406   {
85407     try {
85408       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
85409     } catch (std::out_of_range& e) {
85410       {
85411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85412       };
85413     } catch (std::exception& e) {
85414       {
85415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85416       };
85417     } catch (...) {
85418       {
85419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85420       };
85421     }
85422   }
85423   jresult = new Dali::Actor((const Dali::Actor &)result);
85424   return jresult;
85425 }
85426
85427
85428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
85429   void * jresult ;
85430   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
85431
85432   {
85433     try {
85434       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
85435     } catch (std::out_of_range& e) {
85436       {
85437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85438       };
85439     } catch (std::exception& e) {
85440       {
85441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85442       };
85443     } catch (...) {
85444       {
85445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85446       };
85447     }
85448   }
85449   jresult = (void *)result;
85450   return jresult;
85451 }
85452
85453
85454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
85455   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
85456   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
85457   if (director) {
85458     director->swig_connect_director(callback0);
85459   }
85460 }
85461
85462
85463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
85464   KeyboardFocusManager arg1 ;
85465   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
85466   KeyboardFocusManager *argp1 ;
85467
85468   argp1 = (KeyboardFocusManager *)jarg1;
85469   if (!argp1) {
85470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
85471     return ;
85472   }
85473   arg1 = *argp1;
85474   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
85475   if (!arg2) {
85476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
85477     return ;
85478   }
85479   {
85480     try {
85481       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
85482     } catch (std::out_of_range& e) {
85483       {
85484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85485       };
85486     } catch (std::exception& e) {
85487       {
85488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85489       };
85490     } catch (...) {
85491       {
85492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85493       };
85494     }
85495   }
85496 }
85497
85498
85499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
85500   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85501
85502   arg1 = (std::vector< unsigned int > *)jarg1;
85503   {
85504     try {
85505       (arg1)->clear();
85506     } catch (std::out_of_range& e) {
85507       {
85508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85509       };
85510     } catch (std::exception& e) {
85511       {
85512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85513       };
85514     } catch (...) {
85515       {
85516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85517       };
85518     }
85519   }
85520 }
85521
85522
85523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
85524   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85525   unsigned int *arg2 = 0 ;
85526   unsigned int temp2 ;
85527
85528   arg1 = (std::vector< unsigned int > *)jarg1;
85529   temp2 = (unsigned int)jarg2;
85530   arg2 = &temp2;
85531   {
85532     try {
85533       (arg1)->push_back((unsigned int const &)*arg2);
85534     } catch (std::out_of_range& e) {
85535       {
85536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85537       };
85538     } catch (std::exception& e) {
85539       {
85540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85541       };
85542     } catch (...) {
85543       {
85544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85545       };
85546     }
85547   }
85548 }
85549
85550
85551 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
85552   unsigned long jresult ;
85553   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85554   std::vector< unsigned int >::size_type result;
85555
85556   arg1 = (std::vector< unsigned int > *)jarg1;
85557   {
85558     try {
85559       result = ((std::vector< unsigned int > const *)arg1)->size();
85560     } catch (std::out_of_range& e) {
85561       {
85562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85563       };
85564     } catch (std::exception& e) {
85565       {
85566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85567       };
85568     } catch (...) {
85569       {
85570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85571       };
85572     }
85573   }
85574   jresult = (unsigned long)result;
85575   return jresult;
85576 }
85577
85578
85579 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
85580   unsigned long jresult ;
85581   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85582   std::vector< unsigned int >::size_type result;
85583
85584   arg1 = (std::vector< unsigned int > *)jarg1;
85585   {
85586     try {
85587       result = ((std::vector< unsigned int > const *)arg1)->capacity();
85588     } catch (std::out_of_range& e) {
85589       {
85590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85591       };
85592     } catch (std::exception& e) {
85593       {
85594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85595       };
85596     } catch (...) {
85597       {
85598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85599       };
85600     }
85601   }
85602   jresult = (unsigned long)result;
85603   return jresult;
85604 }
85605
85606
85607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
85608   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85609   std::vector< unsigned int >::size_type arg2 ;
85610
85611   arg1 = (std::vector< unsigned int > *)jarg1;
85612   arg2 = (std::vector< unsigned int >::size_type)jarg2;
85613   {
85614     try {
85615       (arg1)->reserve(arg2);
85616     } catch (std::out_of_range& e) {
85617       {
85618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85619       };
85620     } catch (std::exception& e) {
85621       {
85622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85623       };
85624     } catch (...) {
85625       {
85626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85627       };
85628     }
85629   }
85630 }
85631
85632
85633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
85634   void * jresult ;
85635   std::vector< unsigned int > *result = 0 ;
85636
85637   {
85638     try {
85639       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
85640     } catch (std::out_of_range& e) {
85641       {
85642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85643       };
85644     } catch (std::exception& e) {
85645       {
85646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85647       };
85648     } catch (...) {
85649       {
85650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85651       };
85652     }
85653   }
85654   jresult = (void *)result;
85655   return jresult;
85656 }
85657
85658
85659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
85660   void * jresult ;
85661   std::vector< unsigned int > *arg1 = 0 ;
85662   std::vector< unsigned int > *result = 0 ;
85663
85664   arg1 = (std::vector< unsigned int > *)jarg1;
85665   if (!arg1) {
85666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85667     return 0;
85668   }
85669   {
85670     try {
85671       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
85672     } catch (std::out_of_range& e) {
85673       {
85674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85675       };
85676     } catch (std::exception& e) {
85677       {
85678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85679       };
85680     } catch (...) {
85681       {
85682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85683       };
85684     }
85685   }
85686   jresult = (void *)result;
85687   return jresult;
85688 }
85689
85690
85691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
85692   void * jresult ;
85693   int arg1 ;
85694   std::vector< unsigned int > *result = 0 ;
85695
85696   arg1 = (int)jarg1;
85697   {
85698     try {
85699       try {
85700         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
85701       }
85702       catch(std::out_of_range &_e) {
85703         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85704         return 0;
85705       }
85706
85707     } catch (std::out_of_range& e) {
85708       {
85709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85710       };
85711     } catch (std::exception& e) {
85712       {
85713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85714       };
85715     } catch (...) {
85716       {
85717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85718       };
85719     }
85720   }
85721   jresult = (void *)result;
85722   return jresult;
85723 }
85724
85725
85726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
85727   unsigned int jresult ;
85728   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85729   int arg2 ;
85730   unsigned int result;
85731
85732   arg1 = (std::vector< unsigned int > *)jarg1;
85733   arg2 = (int)jarg2;
85734   {
85735     try {
85736       try {
85737         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
85738       }
85739       catch(std::out_of_range &_e) {
85740         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85741         return 0;
85742       }
85743
85744     } catch (std::out_of_range& e) {
85745       {
85746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85747       };
85748     } catch (std::exception& e) {
85749       {
85750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85751       };
85752     } catch (...) {
85753       {
85754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85755       };
85756     }
85757   }
85758   jresult = result;
85759   return jresult;
85760 }
85761
85762
85763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
85764   unsigned int jresult ;
85765   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85766   int arg2 ;
85767   unsigned int *result = 0 ;
85768
85769   arg1 = (std::vector< unsigned int > *)jarg1;
85770   arg2 = (int)jarg2;
85771   {
85772     try {
85773       try {
85774         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
85775       }
85776       catch(std::out_of_range &_e) {
85777         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85778         return 0;
85779       }
85780
85781     } catch (std::out_of_range& e) {
85782       {
85783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85784       };
85785     } catch (std::exception& e) {
85786       {
85787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85788       };
85789     } catch (...) {
85790       {
85791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85792       };
85793     }
85794   }
85795   jresult = *result;
85796   return jresult;
85797 }
85798
85799
85800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
85801   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85802   int arg2 ;
85803   unsigned int *arg3 = 0 ;
85804   unsigned int temp3 ;
85805
85806   arg1 = (std::vector< unsigned int > *)jarg1;
85807   arg2 = (int)jarg2;
85808   temp3 = (unsigned int)jarg3;
85809   arg3 = &temp3;
85810   {
85811     try {
85812       try {
85813         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
85814       }
85815       catch(std::out_of_range &_e) {
85816         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85817         return ;
85818       }
85819
85820     } catch (std::out_of_range& e) {
85821       {
85822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85823       };
85824     } catch (std::exception& e) {
85825       {
85826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85827       };
85828     } catch (...) {
85829       {
85830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85831       };
85832     }
85833   }
85834 }
85835
85836
85837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
85838   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85839   std::vector< unsigned int > *arg2 = 0 ;
85840
85841   arg1 = (std::vector< unsigned int > *)jarg1;
85842   arg2 = (std::vector< unsigned int > *)jarg2;
85843   if (!arg2) {
85844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85845     return ;
85846   }
85847   {
85848     try {
85849       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
85850     } catch (std::out_of_range& e) {
85851       {
85852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85853       };
85854     } catch (std::exception& e) {
85855       {
85856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85857       };
85858     } catch (...) {
85859       {
85860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85861       };
85862     }
85863   }
85864 }
85865
85866
85867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
85868   void * jresult ;
85869   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85870   int arg2 ;
85871   int arg3 ;
85872   std::vector< unsigned int > *result = 0 ;
85873
85874   arg1 = (std::vector< unsigned int > *)jarg1;
85875   arg2 = (int)jarg2;
85876   arg3 = (int)jarg3;
85877   {
85878     try {
85879       try {
85880         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
85881       }
85882       catch(std::out_of_range &_e) {
85883         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85884         return 0;
85885       }
85886       catch(std::invalid_argument &_e) {
85887         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
85888         return 0;
85889       }
85890
85891     } catch (std::out_of_range& e) {
85892       {
85893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85894       };
85895     } catch (std::exception& e) {
85896       {
85897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85898       };
85899     } catch (...) {
85900       {
85901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85902       };
85903     }
85904   }
85905   jresult = (void *)result;
85906   return jresult;
85907 }
85908
85909
85910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
85911   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85912   int arg2 ;
85913   unsigned int *arg3 = 0 ;
85914   unsigned int temp3 ;
85915
85916   arg1 = (std::vector< unsigned int > *)jarg1;
85917   arg2 = (int)jarg2;
85918   temp3 = (unsigned int)jarg3;
85919   arg3 = &temp3;
85920   {
85921     try {
85922       try {
85923         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
85924       }
85925       catch(std::out_of_range &_e) {
85926         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85927         return ;
85928       }
85929
85930     } catch (std::out_of_range& e) {
85931       {
85932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85933       };
85934     } catch (std::exception& e) {
85935       {
85936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85937       };
85938     } catch (...) {
85939       {
85940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85941       };
85942     }
85943   }
85944 }
85945
85946
85947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
85948   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85949   int arg2 ;
85950   std::vector< unsigned int > *arg3 = 0 ;
85951
85952   arg1 = (std::vector< unsigned int > *)jarg1;
85953   arg2 = (int)jarg2;
85954   arg3 = (std::vector< unsigned int > *)jarg3;
85955   if (!arg3) {
85956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85957     return ;
85958   }
85959   {
85960     try {
85961       try {
85962         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
85963       }
85964       catch(std::out_of_range &_e) {
85965         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85966         return ;
85967       }
85968
85969     } catch (std::out_of_range& e) {
85970       {
85971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85972       };
85973     } catch (std::exception& e) {
85974       {
85975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85976       };
85977     } catch (...) {
85978       {
85979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85980       };
85981     }
85982   }
85983 }
85984
85985
85986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
85987   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85988   int arg2 ;
85989
85990   arg1 = (std::vector< unsigned int > *)jarg1;
85991   arg2 = (int)jarg2;
85992   {
85993     try {
85994       try {
85995         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
85996       }
85997       catch(std::out_of_range &_e) {
85998         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85999         return ;
86000       }
86001
86002     } catch (std::out_of_range& e) {
86003       {
86004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86005       };
86006     } catch (std::exception& e) {
86007       {
86008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86009       };
86010     } catch (...) {
86011       {
86012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86013       };
86014     }
86015   }
86016 }
86017
86018
86019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86020   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86021   int arg2 ;
86022   int arg3 ;
86023
86024   arg1 = (std::vector< unsigned int > *)jarg1;
86025   arg2 = (int)jarg2;
86026   arg3 = (int)jarg3;
86027   {
86028     try {
86029       try {
86030         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
86031       }
86032       catch(std::out_of_range &_e) {
86033         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86034         return ;
86035       }
86036       catch(std::invalid_argument &_e) {
86037         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86038         return ;
86039       }
86040
86041     } catch (std::out_of_range& e) {
86042       {
86043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86044       };
86045     } catch (std::exception& e) {
86046       {
86047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86048       };
86049     } catch (...) {
86050       {
86051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86052       };
86053     }
86054   }
86055 }
86056
86057
86058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
86059   void * jresult ;
86060   unsigned int *arg1 = 0 ;
86061   int arg2 ;
86062   unsigned int temp1 ;
86063   std::vector< unsigned int > *result = 0 ;
86064
86065   temp1 = (unsigned int)jarg1;
86066   arg1 = &temp1;
86067   arg2 = (int)jarg2;
86068   {
86069     try {
86070       try {
86071         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
86072       }
86073       catch(std::out_of_range &_e) {
86074         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86075         return 0;
86076       }
86077
86078     } catch (std::out_of_range& e) {
86079       {
86080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86081       };
86082     } catch (std::exception& e) {
86083       {
86084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86085       };
86086     } catch (...) {
86087       {
86088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86089       };
86090     }
86091   }
86092   jresult = (void *)result;
86093   return jresult;
86094 }
86095
86096
86097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
86098   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86099
86100   arg1 = (std::vector< unsigned int > *)jarg1;
86101   {
86102     try {
86103       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
86104     } catch (std::out_of_range& e) {
86105       {
86106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86107       };
86108     } catch (std::exception& e) {
86109       {
86110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86111       };
86112     } catch (...) {
86113       {
86114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86115       };
86116     }
86117   }
86118 }
86119
86120
86121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86122   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86123   int arg2 ;
86124   int arg3 ;
86125
86126   arg1 = (std::vector< unsigned int > *)jarg1;
86127   arg2 = (int)jarg2;
86128   arg3 = (int)jarg3;
86129   {
86130     try {
86131       try {
86132         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86133       }
86134       catch(std::out_of_range &_e) {
86135         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86136         return ;
86137       }
86138       catch(std::invalid_argument &_e) {
86139         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86140         return ;
86141       }
86142
86143     } catch (std::out_of_range& e) {
86144       {
86145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86146       };
86147     } catch (std::exception& e) {
86148       {
86149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86150       };
86151     } catch (...) {
86152       {
86153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86154       };
86155     }
86156   }
86157 }
86158
86159
86160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86161   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86162   int arg2 ;
86163   std::vector< unsigned int > *arg3 = 0 ;
86164
86165   arg1 = (std::vector< unsigned int > *)jarg1;
86166   arg2 = (int)jarg2;
86167   arg3 = (std::vector< unsigned int > *)jarg3;
86168   if (!arg3) {
86169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86170     return ;
86171   }
86172   {
86173     try {
86174       try {
86175         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86176       }
86177       catch(std::out_of_range &_e) {
86178         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86179         return ;
86180       }
86181
86182     } catch (std::out_of_range& e) {
86183       {
86184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86185       };
86186     } catch (std::exception& e) {
86187       {
86188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86189       };
86190     } catch (...) {
86191       {
86192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86193       };
86194     }
86195   }
86196 }
86197
86198
86199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
86200   unsigned int jresult ;
86201   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86202   unsigned int *arg2 = 0 ;
86203   unsigned int temp2 ;
86204   bool result;
86205
86206   arg1 = (std::vector< unsigned int > *)jarg1;
86207   temp2 = (unsigned int)jarg2;
86208   arg2 = &temp2;
86209   {
86210     try {
86211       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
86212     } catch (std::out_of_range& e) {
86213       {
86214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86215       };
86216     } catch (std::exception& e) {
86217       {
86218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86219       };
86220     } catch (...) {
86221       {
86222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86223       };
86224     }
86225   }
86226   jresult = result;
86227   return jresult;
86228 }
86229
86230
86231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
86232   int jresult ;
86233   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86234   unsigned int *arg2 = 0 ;
86235   unsigned int temp2 ;
86236   int result;
86237
86238   arg1 = (std::vector< unsigned int > *)jarg1;
86239   temp2 = (unsigned int)jarg2;
86240   arg2 = &temp2;
86241   {
86242     try {
86243       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
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 (...) {
86253       {
86254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86255       };
86256     }
86257   }
86258   jresult = result;
86259   return jresult;
86260 }
86261
86262
86263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
86264   int jresult ;
86265   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86266   unsigned int *arg2 = 0 ;
86267   unsigned int temp2 ;
86268   int result;
86269
86270   arg1 = (std::vector< unsigned int > *)jarg1;
86271   temp2 = (unsigned int)jarg2;
86272   arg2 = &temp2;
86273   {
86274     try {
86275       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
86276     } catch (std::out_of_range& e) {
86277       {
86278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86279       };
86280     } catch (std::exception& e) {
86281       {
86282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86283       };
86284     } catch (...) {
86285       {
86286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86287       };
86288     }
86289   }
86290   jresult = result;
86291   return jresult;
86292 }
86293
86294
86295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
86296   unsigned int jresult ;
86297   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86298   unsigned int *arg2 = 0 ;
86299   unsigned int temp2 ;
86300   bool result;
86301
86302   arg1 = (std::vector< unsigned int > *)jarg1;
86303   temp2 = (unsigned int)jarg2;
86304   arg2 = &temp2;
86305   {
86306     try {
86307       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
86308     } catch (std::out_of_range& e) {
86309       {
86310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86311       };
86312     } catch (std::exception& e) {
86313       {
86314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86315       };
86316     } catch (...) {
86317       {
86318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86319       };
86320     }
86321   }
86322   jresult = result;
86323   return jresult;
86324 }
86325
86326
86327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
86328   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86329
86330   arg1 = (std::vector< unsigned int > *)jarg1;
86331   {
86332     try {
86333       delete arg1;
86334     } catch (std::out_of_range& e) {
86335       {
86336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86337       };
86338     } catch (std::exception& e) {
86339       {
86340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86341       };
86342     } catch (...) {
86343       {
86344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86345       };
86346     }
86347   }
86348 }
86349
86350
86351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
86352   void * jresult ;
86353   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86354
86355   {
86356     try {
86357       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
86358     } catch (std::out_of_range& e) {
86359       {
86360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86361       };
86362     } catch (std::exception& e) {
86363       {
86364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86365       };
86366     } catch (...) {
86367       {
86368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86369       };
86370     }
86371   }
86372   jresult = (void *)result;
86373   return jresult;
86374 }
86375
86376
86377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
86378   void * jresult ;
86379   unsigned int arg1 ;
86380   Dali::Actor arg2 ;
86381   Dali::Actor *argp2 ;
86382   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86383
86384   arg1 = (unsigned int)jarg1;
86385   argp2 = (Dali::Actor *)jarg2;
86386   if (!argp2) {
86387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86388     return 0;
86389   }
86390   arg2 = *argp2;
86391   {
86392     try {
86393       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86394     } catch (std::out_of_range& e) {
86395       {
86396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86397       };
86398     } catch (std::exception& e) {
86399       {
86400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86401       };
86402     } catch (...) {
86403       {
86404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86405       };
86406     }
86407   }
86408   jresult = (void *)result;
86409   return jresult;
86410 }
86411
86412
86413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
86414   void * jresult ;
86415   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86416   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86417
86418   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86419   if (!arg1) {
86420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86421     return 0;
86422   }
86423   {
86424     try {
86425       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86426     } catch (std::out_of_range& e) {
86427       {
86428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86429       };
86430     } catch (std::exception& e) {
86431       {
86432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86433       };
86434     } catch (...) {
86435       {
86436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86437       };
86438     }
86439   }
86440   jresult = (void *)result;
86441   return jresult;
86442 }
86443
86444
86445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
86446   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86447   unsigned int arg2 ;
86448
86449   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86450   arg2 = (unsigned int)jarg2;
86451   if (arg1) (arg1)->first = arg2;
86452 }
86453
86454
86455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
86456   unsigned int jresult ;
86457   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86458   unsigned int result;
86459
86460   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86461   result = (unsigned int) ((arg1)->first);
86462   jresult = result;
86463   return jresult;
86464 }
86465
86466
86467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
86468   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86469   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86470
86471   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86472   arg2 = (Dali::Actor *)jarg2;
86473   if (arg1) (arg1)->second = *arg2;
86474 }
86475
86476
86477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
86478   void * jresult ;
86479   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86480   Dali::Actor *result = 0 ;
86481
86482   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86483   result = (Dali::Actor *)& ((arg1)->second);
86484   jresult = (void *)result;
86485   return jresult;
86486 }
86487
86488
86489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
86490   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86491
86492   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86493   {
86494     try {
86495       delete arg1;
86496     } catch (std::out_of_range& e) {
86497       {
86498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86499       };
86500     } catch (std::exception& e) {
86501       {
86502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86503       };
86504     } catch (...) {
86505       {
86506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86507       };
86508     }
86509   }
86510 }
86511
86512
86513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
86514   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86515
86516   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86517   {
86518     try {
86519       (arg1)->clear();
86520     } catch (std::out_of_range& e) {
86521       {
86522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86523       };
86524     } catch (std::exception& e) {
86525       {
86526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86527       };
86528     } catch (...) {
86529       {
86530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86531       };
86532     }
86533   }
86534 }
86535
86536
86537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
86538   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86539   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
86540
86541   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86542   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
86543   if (!arg2) {
86544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86545     return ;
86546   }
86547   {
86548     try {
86549       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
86550     } catch (std::out_of_range& e) {
86551       {
86552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86553       };
86554     } catch (std::exception& e) {
86555       {
86556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86557       };
86558     } catch (...) {
86559       {
86560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86561       };
86562     }
86563   }
86564 }
86565
86566
86567 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
86568   unsigned long jresult ;
86569   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86570   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86571
86572   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86573   {
86574     try {
86575       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
86576     } catch (std::out_of_range& e) {
86577       {
86578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86579       };
86580     } catch (std::exception& e) {
86581       {
86582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86583       };
86584     } catch (...) {
86585       {
86586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86587       };
86588     }
86589   }
86590   jresult = (unsigned long)result;
86591   return jresult;
86592 }
86593
86594
86595 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
86596   unsigned long jresult ;
86597   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86598   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86599
86600   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86601   {
86602     try {
86603       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
86604     } catch (std::out_of_range& e) {
86605       {
86606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86607       };
86608     } catch (std::exception& e) {
86609       {
86610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86611       };
86612     } catch (...) {
86613       {
86614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86615       };
86616     }
86617   }
86618   jresult = (unsigned long)result;
86619   return jresult;
86620 }
86621
86622
86623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
86624   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86625   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
86626
86627   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86628   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
86629   {
86630     try {
86631       (arg1)->reserve(arg2);
86632     } catch (std::out_of_range& e) {
86633       {
86634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86635       };
86636     } catch (std::exception& e) {
86637       {
86638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86639       };
86640     } catch (...) {
86641       {
86642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86643       };
86644     }
86645   }
86646 }
86647
86648
86649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
86650   void * jresult ;
86651   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86652
86653   {
86654     try {
86655       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
86656     } catch (std::out_of_range& e) {
86657       {
86658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86659       };
86660     } catch (std::exception& e) {
86661       {
86662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86663       };
86664     } catch (...) {
86665       {
86666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86667       };
86668     }
86669   }
86670   jresult = (void *)result;
86671   return jresult;
86672 }
86673
86674
86675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
86676   void * jresult ;
86677   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
86678   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86679
86680   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86681   if (!arg1) {
86682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86683     return 0;
86684   }
86685   {
86686     try {
86687       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);
86688     } catch (std::out_of_range& e) {
86689       {
86690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86691       };
86692     } catch (std::exception& e) {
86693       {
86694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86695       };
86696     } catch (...) {
86697       {
86698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86699       };
86700     }
86701   }
86702   jresult = (void *)result;
86703   return jresult;
86704 }
86705
86706
86707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
86708   void * jresult ;
86709   int arg1 ;
86710   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86711
86712   arg1 = (int)jarg1;
86713   {
86714     try {
86715       try {
86716         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);
86717       }
86718       catch(std::out_of_range &_e) {
86719         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86720         return 0;
86721       }
86722
86723     } catch (std::out_of_range& e) {
86724       {
86725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86726       };
86727     } catch (std::exception& e) {
86728       {
86729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86730       };
86731     } catch (...) {
86732       {
86733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86734       };
86735     }
86736   }
86737   jresult = (void *)result;
86738   return jresult;
86739 }
86740
86741
86742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
86743   void * jresult ;
86744   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86745   int arg2 ;
86746   std::pair< unsigned int,Dali::Actor > result;
86747
86748   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86749   arg2 = (int)jarg2;
86750   {
86751     try {
86752       try {
86753         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
86754       }
86755       catch(std::out_of_range &_e) {
86756         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86757         return 0;
86758       }
86759
86760     } catch (std::out_of_range& e) {
86761       {
86762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86763       };
86764     } catch (std::exception& e) {
86765       {
86766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86767       };
86768     } catch (...) {
86769       {
86770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86771       };
86772     }
86773   }
86774   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
86775   return jresult;
86776 }
86777
86778
86779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
86780   void * jresult ;
86781   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86782   int arg2 ;
86783   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86784
86785   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86786   arg2 = (int)jarg2;
86787   {
86788     try {
86789       try {
86790         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
86791       }
86792       catch(std::out_of_range &_e) {
86793         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86794         return 0;
86795       }
86796
86797     } catch (std::out_of_range& e) {
86798       {
86799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86800       };
86801     } catch (std::exception& e) {
86802       {
86803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86804       };
86805     } catch (...) {
86806       {
86807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86808       };
86809     }
86810   }
86811   jresult = (void *)result;
86812   return jresult;
86813 }
86814
86815
86816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
86817   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86818   int arg2 ;
86819   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
86820
86821   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86822   arg2 = (int)jarg2;
86823   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
86824   if (!arg3) {
86825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86826     return ;
86827   }
86828   {
86829     try {
86830       try {
86831         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);
86832       }
86833       catch(std::out_of_range &_e) {
86834         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86835         return ;
86836       }
86837
86838     } catch (std::out_of_range& e) {
86839       {
86840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86841       };
86842     } catch (std::exception& e) {
86843       {
86844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86845       };
86846     } catch (...) {
86847       {
86848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86849       };
86850     }
86851   }
86852 }
86853
86854
86855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
86856   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86857   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
86858
86859   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86860   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
86861   if (!arg2) {
86862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86863     return ;
86864   }
86865   {
86866     try {
86867       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);
86868     } catch (std::out_of_range& e) {
86869       {
86870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86871       };
86872     } catch (std::exception& e) {
86873       {
86874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86875       };
86876     } catch (...) {
86877       {
86878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86879       };
86880     }
86881   }
86882 }
86883
86884
86885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
86886   void * jresult ;
86887   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86888   int arg2 ;
86889   int arg3 ;
86890   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86891
86892   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86893   arg2 = (int)jarg2;
86894   arg3 = (int)jarg3;
86895   {
86896     try {
86897       try {
86898         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);
86899       }
86900       catch(std::out_of_range &_e) {
86901         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86902         return 0;
86903       }
86904       catch(std::invalid_argument &_e) {
86905         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86906         return 0;
86907       }
86908
86909     } catch (std::out_of_range& e) {
86910       {
86911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86912       };
86913     } catch (std::exception& e) {
86914       {
86915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86916       };
86917     } catch (...) {
86918       {
86919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86920       };
86921     }
86922   }
86923   jresult = (void *)result;
86924   return jresult;
86925 }
86926
86927
86928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
86929   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86930   int arg2 ;
86931   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
86932
86933   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86934   arg2 = (int)jarg2;
86935   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
86936   if (!arg3) {
86937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86938     return ;
86939   }
86940   {
86941     try {
86942       try {
86943         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);
86944       }
86945       catch(std::out_of_range &_e) {
86946         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86947         return ;
86948       }
86949
86950     } catch (std::out_of_range& e) {
86951       {
86952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86953       };
86954     } catch (std::exception& e) {
86955       {
86956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86957       };
86958     } catch (...) {
86959       {
86960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86961       };
86962     }
86963   }
86964 }
86965
86966
86967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86968   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86969   int arg2 ;
86970   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
86971
86972   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86973   arg2 = (int)jarg2;
86974   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
86975   if (!arg3) {
86976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86977     return ;
86978   }
86979   {
86980     try {
86981       try {
86982         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);
86983       }
86984       catch(std::out_of_range &_e) {
86985         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86986         return ;
86987       }
86988
86989     } catch (std::out_of_range& e) {
86990       {
86991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86992       };
86993     } catch (std::exception& e) {
86994       {
86995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86996       };
86997     } catch (...) {
86998       {
86999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87000       };
87001     }
87002   }
87003 }
87004
87005
87006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
87007   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87008   int arg2 ;
87009
87010   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87011   arg2 = (int)jarg2;
87012   {
87013     try {
87014       try {
87015         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
87016       }
87017       catch(std::out_of_range &_e) {
87018         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87019         return ;
87020       }
87021
87022     } catch (std::out_of_range& e) {
87023       {
87024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87025       };
87026     } catch (std::exception& e) {
87027       {
87028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87029       };
87030     } catch (...) {
87031       {
87032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87033       };
87034     }
87035   }
87036 }
87037
87038
87039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87040   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87041   int arg2 ;
87042   int arg3 ;
87043
87044   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87045   arg2 = (int)jarg2;
87046   arg3 = (int)jarg3;
87047   {
87048     try {
87049       try {
87050         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
87051       }
87052       catch(std::out_of_range &_e) {
87053         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87054         return ;
87055       }
87056       catch(std::invalid_argument &_e) {
87057         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87058         return ;
87059       }
87060
87061     } catch (std::out_of_range& e) {
87062       {
87063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87064       };
87065     } catch (std::exception& e) {
87066       {
87067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87068       };
87069     } catch (...) {
87070       {
87071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87072       };
87073     }
87074   }
87075 }
87076
87077
87078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
87079   void * jresult ;
87080   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87081   int arg2 ;
87082   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87083
87084   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87085   if (!arg1) {
87086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87087     return 0;
87088   }
87089   arg2 = (int)jarg2;
87090   {
87091     try {
87092       try {
87093         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);
87094       }
87095       catch(std::out_of_range &_e) {
87096         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87097         return 0;
87098       }
87099
87100     } catch (std::out_of_range& e) {
87101       {
87102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87103       };
87104     } catch (std::exception& e) {
87105       {
87106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87107       };
87108     } catch (...) {
87109       {
87110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87111       };
87112     }
87113   }
87114   jresult = (void *)result;
87115   return jresult;
87116 }
87117
87118
87119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
87120   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87121
87122   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87123   {
87124     try {
87125       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
87126     } catch (std::out_of_range& e) {
87127       {
87128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87129       };
87130     } catch (std::exception& e) {
87131       {
87132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87133       };
87134     } catch (...) {
87135       {
87136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87137       };
87138     }
87139   }
87140 }
87141
87142
87143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87144   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87145   int arg2 ;
87146   int arg3 ;
87147
87148   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87149   arg2 = (int)jarg2;
87150   arg3 = (int)jarg3;
87151   {
87152     try {
87153       try {
87154         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87155       }
87156       catch(std::out_of_range &_e) {
87157         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87158         return ;
87159       }
87160       catch(std::invalid_argument &_e) {
87161         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87162         return ;
87163       }
87164
87165     } catch (std::out_of_range& e) {
87166       {
87167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87168       };
87169     } catch (std::exception& e) {
87170       {
87171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87172       };
87173     } catch (...) {
87174       {
87175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87176       };
87177     }
87178   }
87179 }
87180
87181
87182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87183   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87184   int arg2 ;
87185   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87186
87187   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87188   arg2 = (int)jarg2;
87189   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87190   if (!arg3) {
87191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87192     return ;
87193   }
87194   {
87195     try {
87196       try {
87197         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);
87198       }
87199       catch(std::out_of_range &_e) {
87200         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87201         return ;
87202       }
87203
87204     } catch (std::out_of_range& e) {
87205       {
87206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87207       };
87208     } catch (std::exception& e) {
87209       {
87210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87211       };
87212     } catch (...) {
87213       {
87214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87215       };
87216     }
87217   }
87218 }
87219
87220
87221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
87222   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87223
87224   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87225   {
87226     try {
87227       delete arg1;
87228     } catch (std::out_of_range& e) {
87229       {
87230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87231       };
87232     } catch (std::exception& e) {
87233       {
87234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87235       };
87236     } catch (...) {
87237       {
87238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87239       };
87240     }
87241   }
87242 }
87243
87244
87245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
87246   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87247
87248   arg1 = (std::vector< Dali::Actor > *)jarg1;
87249   {
87250     try {
87251       (arg1)->clear();
87252     } catch (std::out_of_range& e) {
87253       {
87254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87255       };
87256     } catch (std::exception& e) {
87257       {
87258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87259       };
87260     } catch (...) {
87261       {
87262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87263       };
87264     }
87265   }
87266 }
87267
87268
87269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
87270   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87271   Dali::Actor *arg2 = 0 ;
87272
87273   arg1 = (std::vector< Dali::Actor > *)jarg1;
87274   arg2 = (Dali::Actor *)jarg2;
87275   if (!arg2) {
87276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87277     return ;
87278   }
87279   {
87280     try {
87281       (arg1)->push_back((Dali::Actor const &)*arg2);
87282     } catch (std::out_of_range& e) {
87283       {
87284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87285       };
87286     } catch (std::exception& e) {
87287       {
87288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87289       };
87290     } catch (...) {
87291       {
87292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87293       };
87294     }
87295   }
87296 }
87297
87298
87299 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
87300   unsigned long jresult ;
87301   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87302   std::vector< Dali::Actor >::size_type result;
87303
87304   arg1 = (std::vector< Dali::Actor > *)jarg1;
87305   {
87306     try {
87307       result = ((std::vector< Dali::Actor > const *)arg1)->size();
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 (...) {
87317       {
87318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87319       };
87320     }
87321   }
87322   jresult = (unsigned long)result;
87323   return jresult;
87324 }
87325
87326
87327 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
87328   unsigned long jresult ;
87329   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87330   std::vector< Dali::Actor >::size_type result;
87331
87332   arg1 = (std::vector< Dali::Actor > *)jarg1;
87333   {
87334     try {
87335       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
87336     } catch (std::out_of_range& e) {
87337       {
87338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87339       };
87340     } catch (std::exception& e) {
87341       {
87342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87343       };
87344     } catch (...) {
87345       {
87346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87347       };
87348     }
87349   }
87350   jresult = (unsigned long)result;
87351   return jresult;
87352 }
87353
87354
87355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
87356   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87357   std::vector< Dali::Actor >::size_type arg2 ;
87358
87359   arg1 = (std::vector< Dali::Actor > *)jarg1;
87360   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
87361   {
87362     try {
87363       (arg1)->reserve(arg2);
87364     } catch (std::out_of_range& e) {
87365       {
87366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87367       };
87368     } catch (std::exception& e) {
87369       {
87370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87371       };
87372     } catch (...) {
87373       {
87374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87375       };
87376     }
87377   }
87378 }
87379
87380
87381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
87382   void * jresult ;
87383   std::vector< Dali::Actor > *result = 0 ;
87384
87385   {
87386     try {
87387       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
87388     } catch (std::out_of_range& e) {
87389       {
87390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87391       };
87392     } catch (std::exception& e) {
87393       {
87394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87395       };
87396     } catch (...) {
87397       {
87398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87399       };
87400     }
87401   }
87402   jresult = (void *)result;
87403   return jresult;
87404 }
87405
87406
87407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
87408   void * jresult ;
87409   std::vector< Dali::Actor > *arg1 = 0 ;
87410   std::vector< Dali::Actor > *result = 0 ;
87411
87412   arg1 = (std::vector< Dali::Actor > *)jarg1;
87413   if (!arg1) {
87414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87415     return 0;
87416   }
87417   {
87418     try {
87419       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87420     } catch (std::out_of_range& e) {
87421       {
87422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87423       };
87424     } catch (std::exception& e) {
87425       {
87426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87427       };
87428     } catch (...) {
87429       {
87430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87431       };
87432     }
87433   }
87434   jresult = (void *)result;
87435   return jresult;
87436 }
87437
87438
87439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
87440   void * jresult ;
87441   int arg1 ;
87442   std::vector< Dali::Actor > *result = 0 ;
87443
87444   arg1 = (int)jarg1;
87445   {
87446     try {
87447       try {
87448         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87449       }
87450       catch(std::out_of_range &_e) {
87451         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87452         return 0;
87453       }
87454
87455     } catch (std::out_of_range& e) {
87456       {
87457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87458       };
87459     } catch (std::exception& e) {
87460       {
87461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87462       };
87463     } catch (...) {
87464       {
87465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87466       };
87467     }
87468   }
87469   jresult = (void *)result;
87470   return jresult;
87471 }
87472
87473
87474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87475   void * jresult ;
87476   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87477   int arg2 ;
87478   Dali::Actor result;
87479
87480   arg1 = (std::vector< Dali::Actor > *)jarg1;
87481   arg2 = (int)jarg2;
87482   {
87483     try {
87484       try {
87485         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
87486       }
87487       catch(std::out_of_range &_e) {
87488         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87489         return 0;
87490       }
87491
87492     } catch (std::out_of_range& e) {
87493       {
87494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87495       };
87496     } catch (std::exception& e) {
87497       {
87498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87499       };
87500     } catch (...) {
87501       {
87502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87503       };
87504     }
87505   }
87506   jresult = new Dali::Actor((const Dali::Actor &)result);
87507   return jresult;
87508 }
87509
87510
87511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
87512   void * jresult ;
87513   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87514   int arg2 ;
87515   Dali::Actor *result = 0 ;
87516
87517   arg1 = (std::vector< Dali::Actor > *)jarg1;
87518   arg2 = (int)jarg2;
87519   {
87520     try {
87521       try {
87522         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
87523       }
87524       catch(std::out_of_range &_e) {
87525         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87526         return 0;
87527       }
87528
87529     } catch (std::out_of_range& e) {
87530       {
87531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87532       };
87533     } catch (std::exception& e) {
87534       {
87535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87536       };
87537     } catch (...) {
87538       {
87539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87540       };
87541     }
87542   }
87543   jresult = (void *)result;
87544   return jresult;
87545 }
87546
87547
87548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87549   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87550   int arg2 ;
87551   Dali::Actor *arg3 = 0 ;
87552
87553   arg1 = (std::vector< Dali::Actor > *)jarg1;
87554   arg2 = (int)jarg2;
87555   arg3 = (Dali::Actor *)jarg3;
87556   if (!arg3) {
87557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87558     return ;
87559   }
87560   {
87561     try {
87562       try {
87563         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
87564       }
87565       catch(std::out_of_range &_e) {
87566         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87567         return ;
87568       }
87569
87570     } catch (std::out_of_range& e) {
87571       {
87572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87573       };
87574     } catch (std::exception& e) {
87575       {
87576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87577       };
87578     } catch (...) {
87579       {
87580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87581       };
87582     }
87583   }
87584 }
87585
87586
87587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
87588   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87589   std::vector< Dali::Actor > *arg2 = 0 ;
87590
87591   arg1 = (std::vector< Dali::Actor > *)jarg1;
87592   arg2 = (std::vector< Dali::Actor > *)jarg2;
87593   if (!arg2) {
87594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87595     return ;
87596   }
87597   {
87598     try {
87599       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
87600     } catch (std::out_of_range& e) {
87601       {
87602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87603       };
87604     } catch (std::exception& e) {
87605       {
87606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87607       };
87608     } catch (...) {
87609       {
87610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87611       };
87612     }
87613   }
87614 }
87615
87616
87617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87618   void * jresult ;
87619   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87620   int arg2 ;
87621   int arg3 ;
87622   std::vector< Dali::Actor > *result = 0 ;
87623
87624   arg1 = (std::vector< Dali::Actor > *)jarg1;
87625   arg2 = (int)jarg2;
87626   arg3 = (int)jarg3;
87627   {
87628     try {
87629       try {
87630         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
87631       }
87632       catch(std::out_of_range &_e) {
87633         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87634         return 0;
87635       }
87636       catch(std::invalid_argument &_e) {
87637         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87638         return 0;
87639       }
87640
87641     } catch (std::out_of_range& e) {
87642       {
87643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87644       };
87645     } catch (std::exception& e) {
87646       {
87647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87648       };
87649     } catch (...) {
87650       {
87651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87652       };
87653     }
87654   }
87655   jresult = (void *)result;
87656   return jresult;
87657 }
87658
87659
87660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87661   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87662   int arg2 ;
87663   Dali::Actor *arg3 = 0 ;
87664
87665   arg1 = (std::vector< Dali::Actor > *)jarg1;
87666   arg2 = (int)jarg2;
87667   arg3 = (Dali::Actor *)jarg3;
87668   if (!arg3) {
87669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87670     return ;
87671   }
87672   {
87673     try {
87674       try {
87675         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
87676       }
87677       catch(std::out_of_range &_e) {
87678         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87679         return ;
87680       }
87681
87682     } catch (std::out_of_range& e) {
87683       {
87684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87685       };
87686     } catch (std::exception& e) {
87687       {
87688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87689       };
87690     } catch (...) {
87691       {
87692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87693       };
87694     }
87695   }
87696 }
87697
87698
87699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87700   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87701   int arg2 ;
87702   std::vector< Dali::Actor > *arg3 = 0 ;
87703
87704   arg1 = (std::vector< Dali::Actor > *)jarg1;
87705   arg2 = (int)jarg2;
87706   arg3 = (std::vector< Dali::Actor > *)jarg3;
87707   if (!arg3) {
87708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87709     return ;
87710   }
87711   {
87712     try {
87713       try {
87714         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
87715       }
87716       catch(std::out_of_range &_e) {
87717         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87718         return ;
87719       }
87720
87721     } catch (std::out_of_range& e) {
87722       {
87723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87724       };
87725     } catch (std::exception& e) {
87726       {
87727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87728       };
87729     } catch (...) {
87730       {
87731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87732       };
87733     }
87734   }
87735 }
87736
87737
87738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
87739   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87740   int arg2 ;
87741
87742   arg1 = (std::vector< Dali::Actor > *)jarg1;
87743   arg2 = (int)jarg2;
87744   {
87745     try {
87746       try {
87747         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
87748       }
87749       catch(std::out_of_range &_e) {
87750         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87751         return ;
87752       }
87753
87754     } catch (std::out_of_range& e) {
87755       {
87756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87757       };
87758     } catch (std::exception& e) {
87759       {
87760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87761       };
87762     } catch (...) {
87763       {
87764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87765       };
87766     }
87767   }
87768 }
87769
87770
87771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87772   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87773   int arg2 ;
87774   int arg3 ;
87775
87776   arg1 = (std::vector< Dali::Actor > *)jarg1;
87777   arg2 = (int)jarg2;
87778   arg3 = (int)jarg3;
87779   {
87780     try {
87781       try {
87782         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
87783       }
87784       catch(std::out_of_range &_e) {
87785         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87786         return ;
87787       }
87788       catch(std::invalid_argument &_e) {
87789         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87790         return ;
87791       }
87792
87793     } catch (std::out_of_range& e) {
87794       {
87795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87796       };
87797     } catch (std::exception& e) {
87798       {
87799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87800       };
87801     } catch (...) {
87802       {
87803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87804       };
87805     }
87806   }
87807 }
87808
87809
87810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
87811   void * jresult ;
87812   Dali::Actor *arg1 = 0 ;
87813   int arg2 ;
87814   std::vector< Dali::Actor > *result = 0 ;
87815
87816   arg1 = (Dali::Actor *)jarg1;
87817   if (!arg1) {
87818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87819     return 0;
87820   }
87821   arg2 = (int)jarg2;
87822   {
87823     try {
87824       try {
87825         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
87826       }
87827       catch(std::out_of_range &_e) {
87828         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87829         return 0;
87830       }
87831
87832     } catch (std::out_of_range& e) {
87833       {
87834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87835       };
87836     } catch (std::exception& e) {
87837       {
87838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87839       };
87840     } catch (...) {
87841       {
87842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87843       };
87844     }
87845   }
87846   jresult = (void *)result;
87847   return jresult;
87848 }
87849
87850
87851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
87852   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87853
87854   arg1 = (std::vector< Dali::Actor > *)jarg1;
87855   {
87856     try {
87857       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
87858     } catch (std::out_of_range& e) {
87859       {
87860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87861       };
87862     } catch (std::exception& e) {
87863       {
87864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87865       };
87866     } catch (...) {
87867       {
87868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87869       };
87870     }
87871   }
87872 }
87873
87874
87875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87876   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87877   int arg2 ;
87878   int arg3 ;
87879
87880   arg1 = (std::vector< Dali::Actor > *)jarg1;
87881   arg2 = (int)jarg2;
87882   arg3 = (int)jarg3;
87883   {
87884     try {
87885       try {
87886         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87887       }
87888       catch(std::out_of_range &_e) {
87889         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87890         return ;
87891       }
87892       catch(std::invalid_argument &_e) {
87893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87894         return ;
87895       }
87896
87897     } catch (std::out_of_range& e) {
87898       {
87899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87900       };
87901     } catch (std::exception& e) {
87902       {
87903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87904       };
87905     } catch (...) {
87906       {
87907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87908       };
87909     }
87910   }
87911 }
87912
87913
87914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87915   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87916   int arg2 ;
87917   std::vector< Dali::Actor > *arg3 = 0 ;
87918
87919   arg1 = (std::vector< Dali::Actor > *)jarg1;
87920   arg2 = (int)jarg2;
87921   arg3 = (std::vector< Dali::Actor > *)jarg3;
87922   if (!arg3) {
87923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87924     return ;
87925   }
87926   {
87927     try {
87928       try {
87929         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
87930       }
87931       catch(std::out_of_range &_e) {
87932         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87933         return ;
87934       }
87935
87936     } catch (std::out_of_range& e) {
87937       {
87938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87939       };
87940     } catch (std::exception& e) {
87941       {
87942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87943       };
87944     } catch (...) {
87945       {
87946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87947       };
87948     }
87949   }
87950 }
87951
87952
87953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
87954   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87955
87956   arg1 = (std::vector< Dali::Actor > *)jarg1;
87957   {
87958     try {
87959       delete arg1;
87960     } catch (std::out_of_range& e) {
87961       {
87962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87963       };
87964     } catch (std::exception& e) {
87965       {
87966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87967       };
87968     } catch (...) {
87969       {
87970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87971       };
87972     }
87973   }
87974 }
87975
87976
87977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
87978   unsigned int jresult ;
87979   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
87980   bool result;
87981
87982   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
87983   {
87984     try {
87985       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
87986     } catch (std::out_of_range& e) {
87987       {
87988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87989       };
87990     } catch (std::exception& e) {
87991       {
87992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87993       };
87994     } catch (...) {
87995       {
87996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87997       };
87998     }
87999   }
88000   jresult = result;
88001   return jresult;
88002 }
88003
88004
88005 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
88006   unsigned long jresult ;
88007   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88008   std::size_t result;
88009
88010   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88011   {
88012     try {
88013       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88014     } catch (std::out_of_range& e) {
88015       {
88016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88017       };
88018     } catch (std::exception& e) {
88019       {
88020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88021       };
88022     } catch (...) {
88023       {
88024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88025       };
88026     }
88027   }
88028   jresult = (unsigned long)result;
88029   return jresult;
88030 }
88031
88032
88033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
88034   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88035   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88036
88037   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88038   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88039   {
88040     try {
88041       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
88042     } catch (std::out_of_range& e) {
88043       {
88044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88045       };
88046     } catch (std::exception& e) {
88047       {
88048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88049       };
88050     } catch (...) {
88051       {
88052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88053       };
88054     }
88055   }
88056 }
88057
88058
88059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
88060   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88061   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88062
88063   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88064   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88065   {
88066     try {
88067       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
88068     } catch (std::out_of_range& e) {
88069       {
88070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88071       };
88072     } catch (std::exception& e) {
88073       {
88074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88075       };
88076     } catch (...) {
88077       {
88078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88079       };
88080     }
88081   }
88082 }
88083
88084
88085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
88086   unsigned int jresult ;
88087   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88088   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88089   bool result;
88090
88091   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88092   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88093   if (!arg2) {
88094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88095     return 0;
88096   }
88097   {
88098     try {
88099       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
88100     } catch (std::out_of_range& e) {
88101       {
88102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88103       };
88104     } catch (std::exception& e) {
88105       {
88106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88107       };
88108     } catch (...) {
88109       {
88110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88111       };
88112     }
88113   }
88114   jresult = result;
88115   return jresult;
88116 }
88117
88118
88119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
88120   void * jresult ;
88121   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
88122
88123   {
88124     try {
88125       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
88126     } catch (std::out_of_range& e) {
88127       {
88128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88129       };
88130     } catch (std::exception& e) {
88131       {
88132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88133       };
88134     } catch (...) {
88135       {
88136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88137       };
88138     }
88139   }
88140   jresult = (void *)result;
88141   return jresult;
88142 }
88143
88144
88145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
88146   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88147
88148   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88149   {
88150     try {
88151       delete arg1;
88152     } catch (std::out_of_range& e) {
88153       {
88154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88155       };
88156     } catch (std::exception& e) {
88157       {
88158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88159       };
88160     } catch (...) {
88161       {
88162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88163       };
88164     }
88165   }
88166 }
88167
88168
88169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
88170   unsigned int jresult ;
88171   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88172   bool result;
88173
88174   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88175   {
88176     try {
88177       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);
88178     } catch (std::out_of_range& e) {
88179       {
88180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88181       };
88182     } catch (std::exception& e) {
88183       {
88184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88185       };
88186     } catch (...) {
88187       {
88188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88189       };
88190     }
88191   }
88192   jresult = result;
88193   return jresult;
88194 }
88195
88196
88197 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
88198   unsigned long jresult ;
88199   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88200   std::size_t result;
88201
88202   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88203   {
88204     try {
88205       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);
88206     } catch (std::out_of_range& e) {
88207       {
88208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88209       };
88210     } catch (std::exception& e) {
88211       {
88212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88213       };
88214     } catch (...) {
88215       {
88216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88217       };
88218     }
88219   }
88220   jresult = (unsigned long)result;
88221   return jresult;
88222 }
88223
88224
88225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
88226   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88227   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88228
88229   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88230   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88231   {
88232     try {
88233       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
88234     } catch (std::out_of_range& e) {
88235       {
88236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88237       };
88238     } catch (std::exception& e) {
88239       {
88240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88241       };
88242     } catch (...) {
88243       {
88244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88245       };
88246     }
88247   }
88248 }
88249
88250
88251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
88252   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88253   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88254
88255   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88256   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88257   {
88258     try {
88259       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
88260     } catch (std::out_of_range& e) {
88261       {
88262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88263       };
88264     } catch (std::exception& e) {
88265       {
88266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88267       };
88268     } catch (...) {
88269       {
88270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88271       };
88272     }
88273   }
88274 }
88275
88276
88277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88278   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88279   Dali::Actor arg2 ;
88280   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
88281   Dali::Actor *argp2 ;
88282
88283   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88284   argp2 = (Dali::Actor *)jarg2;
88285   if (!argp2) {
88286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88287     return ;
88288   }
88289   arg2 = *argp2;
88290   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
88291   {
88292     try {
88293       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
88294     } catch (std::out_of_range& e) {
88295       {
88296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88297       };
88298     } catch (std::exception& e) {
88299       {
88300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88301       };
88302     } catch (...) {
88303       {
88304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88305       };
88306     }
88307   }
88308 }
88309
88310
88311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
88312   void * jresult ;
88313   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
88314
88315   {
88316     try {
88317       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
88318     } catch (std::out_of_range& e) {
88319       {
88320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88321       };
88322     } catch (std::exception& e) {
88323       {
88324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88325       };
88326     } catch (...) {
88327       {
88328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88329       };
88330     }
88331   }
88332   jresult = (void *)result;
88333   return jresult;
88334 }
88335
88336
88337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
88338   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88339
88340   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88341   {
88342     try {
88343       delete arg1;
88344     } catch (std::out_of_range& e) {
88345       {
88346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88347       };
88348     } catch (std::exception& e) {
88349       {
88350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88351       };
88352     } catch (...) {
88353       {
88354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88355       };
88356     }
88357   }
88358 }
88359
88360
88361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
88362   unsigned int jresult ;
88363   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88364   bool result;
88365
88366   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88367   {
88368     try {
88369       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88370     } catch (std::out_of_range& e) {
88371       {
88372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88373       };
88374     } catch (std::exception& e) {
88375       {
88376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88377       };
88378     } catch (...) {
88379       {
88380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88381       };
88382     }
88383   }
88384   jresult = result;
88385   return jresult;
88386 }
88387
88388
88389 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
88390   unsigned long jresult ;
88391   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88392   std::size_t result;
88393
88394   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88395   {
88396     try {
88397       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88398     } catch (std::out_of_range& e) {
88399       {
88400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88401       };
88402     } catch (std::exception& e) {
88403       {
88404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88405       };
88406     } catch (...) {
88407       {
88408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88409       };
88410     }
88411   }
88412   jresult = (unsigned long)result;
88413   return jresult;
88414 }
88415
88416
88417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
88418   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88419   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88420
88421   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88422   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88423   {
88424     try {
88425       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
88426     } catch (std::out_of_range& e) {
88427       {
88428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88429       };
88430     } catch (std::exception& e) {
88431       {
88432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88433       };
88434     } catch (...) {
88435       {
88436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88437       };
88438     }
88439   }
88440 }
88441
88442
88443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88444   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88445   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88446
88447   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88448   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88449   {
88450     try {
88451       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
88452     } catch (std::out_of_range& e) {
88453       {
88454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88455       };
88456     } catch (std::exception& e) {
88457       {
88458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88459       };
88460     } catch (...) {
88461       {
88462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88463       };
88464     }
88465   }
88466 }
88467
88468
88469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88470   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88471   Dali::Actor arg2 ;
88472   Dali::Actor arg3 ;
88473   Dali::Actor *argp2 ;
88474   Dali::Actor *argp3 ;
88475
88476   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88477   argp2 = (Dali::Actor *)jarg2;
88478   if (!argp2) {
88479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88480     return ;
88481   }
88482   arg2 = *argp2;
88483   argp3 = (Dali::Actor *)jarg3;
88484   if (!argp3) {
88485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88486     return ;
88487   }
88488   arg3 = *argp3;
88489   {
88490     try {
88491       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
88492     } catch (std::out_of_range& e) {
88493       {
88494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88495       };
88496     } catch (std::exception& e) {
88497       {
88498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88499       };
88500     } catch (...) {
88501       {
88502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88503       };
88504     }
88505   }
88506 }
88507
88508
88509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
88510   void * jresult ;
88511   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
88512
88513   {
88514     try {
88515       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
88516     } catch (std::out_of_range& e) {
88517       {
88518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88519       };
88520     } catch (std::exception& e) {
88521       {
88522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88523       };
88524     } catch (...) {
88525       {
88526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88527       };
88528     }
88529   }
88530   jresult = (void *)result;
88531   return jresult;
88532 }
88533
88534
88535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
88536   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88537
88538   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88539   {
88540     try {
88541       delete arg1;
88542     } catch (std::out_of_range& e) {
88543       {
88544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88545       };
88546     } catch (std::exception& e) {
88547       {
88548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88549       };
88550     } catch (...) {
88551       {
88552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88553       };
88554     }
88555   }
88556 }
88557
88558
88559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
88560   unsigned int jresult ;
88561   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88562   bool result;
88563
88564   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88565   {
88566     try {
88567       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88568     } catch (std::out_of_range& e) {
88569       {
88570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88571       };
88572     } catch (std::exception& e) {
88573       {
88574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88575       };
88576     } catch (...) {
88577       {
88578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88579       };
88580     }
88581   }
88582   jresult = result;
88583   return jresult;
88584 }
88585
88586
88587 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
88588   unsigned long jresult ;
88589   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88590   std::size_t result;
88591
88592   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88593   {
88594     try {
88595       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88596     } catch (std::out_of_range& e) {
88597       {
88598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88599       };
88600     } catch (std::exception& e) {
88601       {
88602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88603       };
88604     } catch (...) {
88605       {
88606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88607       };
88608     }
88609   }
88610   jresult = (unsigned long)result;
88611   return jresult;
88612 }
88613
88614
88615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
88616   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88617   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88618
88619   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88620   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88621   {
88622     try {
88623       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
88624     } catch (std::out_of_range& e) {
88625       {
88626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88627       };
88628     } catch (std::exception& e) {
88629       {
88630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88631       };
88632     } catch (...) {
88633       {
88634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88635       };
88636     }
88637   }
88638 }
88639
88640
88641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88642   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88643   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88644
88645   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88646   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88647   {
88648     try {
88649       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
88650     } catch (std::out_of_range& e) {
88651       {
88652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88653       };
88654     } catch (std::exception& e) {
88655       {
88656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88657       };
88658     } catch (...) {
88659       {
88660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88661       };
88662     }
88663   }
88664 }
88665
88666
88667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
88668   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88669   Dali::Actor arg2 ;
88670   bool arg3 ;
88671   Dali::Actor *argp2 ;
88672
88673   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88674   argp2 = (Dali::Actor *)jarg2;
88675   if (!argp2) {
88676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88677     return ;
88678   }
88679   arg2 = *argp2;
88680   arg3 = jarg3 ? true : false;
88681   {
88682     try {
88683       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
88684     } catch (std::out_of_range& e) {
88685       {
88686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88687       };
88688     } catch (std::exception& e) {
88689       {
88690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88691       };
88692     } catch (...) {
88693       {
88694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88695       };
88696     }
88697   }
88698 }
88699
88700
88701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
88702   void * jresult ;
88703   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
88704
88705   {
88706     try {
88707       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
88708     } catch (std::out_of_range& e) {
88709       {
88710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88711       };
88712     } catch (std::exception& e) {
88713       {
88714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88715       };
88716     } catch (...) {
88717       {
88718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88719       };
88720     }
88721   }
88722   jresult = (void *)result;
88723   return jresult;
88724 }
88725
88726
88727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
88728   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88729
88730   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88731   {
88732     try {
88733       delete arg1;
88734     } catch (std::out_of_range& e) {
88735       {
88736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88737       };
88738     } catch (std::exception& e) {
88739       {
88740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88741       };
88742     } catch (...) {
88743       {
88744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88745       };
88746     }
88747   }
88748 }
88749
88750
88751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
88752   unsigned int jresult ;
88753   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88754   bool result;
88755
88756   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88757   {
88758     try {
88759       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);
88760     } catch (std::out_of_range& e) {
88761       {
88762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88763       };
88764     } catch (std::exception& e) {
88765       {
88766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88767       };
88768     } catch (...) {
88769       {
88770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88771       };
88772     }
88773   }
88774   jresult = result;
88775   return jresult;
88776 }
88777
88778
88779 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
88780   unsigned long jresult ;
88781   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88782   std::size_t result;
88783
88784   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88785   {
88786     try {
88787       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);
88788     } catch (std::out_of_range& e) {
88789       {
88790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88791       };
88792     } catch (std::exception& e) {
88793       {
88794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88795       };
88796     } catch (...) {
88797       {
88798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88799       };
88800     }
88801   }
88802   jresult = (unsigned long)result;
88803   return jresult;
88804 }
88805
88806
88807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
88808   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88809   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
88810
88811   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88812   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
88813   {
88814     try {
88815       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
88816     } catch (std::out_of_range& e) {
88817       {
88818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88819       };
88820     } catch (std::exception& e) {
88821       {
88822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88823       };
88824     } catch (...) {
88825       {
88826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88827       };
88828     }
88829   }
88830 }
88831
88832
88833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88834   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88835   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
88836
88837   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88838   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
88839   {
88840     try {
88841       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
88842     } catch (std::out_of_range& e) {
88843       {
88844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88845       };
88846     } catch (std::exception& e) {
88847       {
88848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88849       };
88850     } catch (...) {
88851       {
88852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88853       };
88854     }
88855   }
88856 }
88857
88858
88859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88860   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88861   Dali::Toolkit::StyleManager arg2 ;
88862   Dali::StyleChange::Type arg3 ;
88863   Dali::Toolkit::StyleManager *argp2 ;
88864
88865   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88866   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
88867   if (!argp2) {
88868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
88869     return ;
88870   }
88871   arg2 = *argp2;
88872   arg3 = (Dali::StyleChange::Type)jarg3;
88873   {
88874     try {
88875       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
88876     } catch (std::out_of_range& e) {
88877       {
88878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88879       };
88880     } catch (std::exception& e) {
88881       {
88882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88883       };
88884     } catch (...) {
88885       {
88886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88887       };
88888     }
88889   }
88890 }
88891
88892
88893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
88894   void * jresult ;
88895   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
88896
88897   {
88898     try {
88899       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
88900     } catch (std::out_of_range& e) {
88901       {
88902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88903       };
88904     } catch (std::exception& e) {
88905       {
88906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88907       };
88908     } catch (...) {
88909       {
88910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88911       };
88912     }
88913   }
88914   jresult = (void *)result;
88915   return jresult;
88916 }
88917
88918
88919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
88920   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
88921
88922   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
88923   {
88924     try {
88925       delete arg1;
88926     } catch (std::out_of_range& e) {
88927       {
88928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88929       };
88930     } catch (std::exception& e) {
88931       {
88932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88933       };
88934     } catch (...) {
88935       {
88936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88937       };
88938     }
88939   }
88940 }
88941
88942
88943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
88944   unsigned int jresult ;
88945   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88946   bool result;
88947
88948   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88949   {
88950     try {
88951       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
88952     } catch (std::out_of_range& e) {
88953       {
88954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88955       };
88956     } catch (std::exception& e) {
88957       {
88958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88959       };
88960     } catch (...) {
88961       {
88962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88963       };
88964     }
88965   }
88966   jresult = result;
88967   return jresult;
88968 }
88969
88970
88971 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
88972   unsigned long jresult ;
88973   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
88974   std::size_t result;
88975
88976   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
88977   {
88978     try {
88979       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
88980     } catch (std::out_of_range& e) {
88981       {
88982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88983       };
88984     } catch (std::exception& e) {
88985       {
88986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88987       };
88988     } catch (...) {
88989       {
88990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88991       };
88992     }
88993   }
88994   jresult = (unsigned long)result;
88995   return jresult;
88996 }
88997
88998
88999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
89000   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89001   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89002
89003   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89004   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89005   {
89006     try {
89007       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
89008     } catch (std::out_of_range& e) {
89009       {
89010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89011       };
89012     } catch (std::exception& e) {
89013       {
89014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89015       };
89016     } catch (...) {
89017       {
89018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89019       };
89020     }
89021   }
89022 }
89023
89024
89025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
89026   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89027   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89028
89029   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89030   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89031   {
89032     try {
89033       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
89034     } catch (std::out_of_range& e) {
89035       {
89036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89037       };
89038     } catch (std::exception& e) {
89039       {
89040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89041       };
89042     } catch (...) {
89043       {
89044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89045       };
89046     }
89047   }
89048 }
89049
89050
89051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
89052   unsigned int jresult ;
89053   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89054   Dali::Toolkit::Button arg2 ;
89055   Dali::Toolkit::Button *argp2 ;
89056   bool result;
89057
89058   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89059   argp2 = (Dali::Toolkit::Button *)jarg2;
89060   if (!argp2) {
89061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
89062     return 0;
89063   }
89064   arg2 = *argp2;
89065   {
89066     try {
89067       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
89068     } catch (std::out_of_range& e) {
89069       {
89070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89071       };
89072     } catch (std::exception& e) {
89073       {
89074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89075       };
89076     } catch (...) {
89077       {
89078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89079       };
89080     }
89081   }
89082   jresult = result;
89083   return jresult;
89084 }
89085
89086
89087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
89088   void * jresult ;
89089   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
89090
89091   {
89092     try {
89093       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
89094     } catch (std::out_of_range& e) {
89095       {
89096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89097       };
89098     } catch (std::exception& e) {
89099       {
89100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89101       };
89102     } catch (...) {
89103       {
89104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89105       };
89106     }
89107   }
89108   jresult = (void *)result;
89109   return jresult;
89110 }
89111
89112
89113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
89114   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89115
89116   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89117   {
89118     try {
89119       delete arg1;
89120     } catch (std::out_of_range& e) {
89121       {
89122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89123       };
89124     } catch (std::exception& e) {
89125       {
89126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89127       };
89128     } catch (...) {
89129       {
89130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89131       };
89132     }
89133   }
89134 }
89135
89136
89137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
89138   unsigned int jresult ;
89139   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89140   bool result;
89141
89142   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89143   {
89144     try {
89145       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89146     } catch (std::out_of_range& e) {
89147       {
89148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89149       };
89150     } catch (std::exception& e) {
89151       {
89152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89153       };
89154     } catch (...) {
89155       {
89156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89157       };
89158     }
89159   }
89160   jresult = result;
89161   return jresult;
89162 }
89163
89164
89165 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
89166   unsigned long jresult ;
89167   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89168   std::size_t result;
89169
89170   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89171   {
89172     try {
89173       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89174     } catch (std::out_of_range& e) {
89175       {
89176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89177       };
89178     } catch (std::exception& e) {
89179       {
89180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89181       };
89182     } catch (...) {
89183       {
89184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89185       };
89186     }
89187   }
89188   jresult = (unsigned long)result;
89189   return jresult;
89190 }
89191
89192
89193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
89194   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89195   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89196
89197   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89198   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89199   {
89200     try {
89201       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
89202     } catch (std::out_of_range& e) {
89203       {
89204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89205       };
89206     } catch (std::exception& e) {
89207       {
89208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89209       };
89210     } catch (...) {
89211       {
89212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89213       };
89214     }
89215   }
89216 }
89217
89218
89219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
89220   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89221   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89222
89223   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89224   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89225   {
89226     try {
89227       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
89228     } catch (std::out_of_range& e) {
89229       {
89230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89231       };
89232     } catch (std::exception& e) {
89233       {
89234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89235       };
89236     } catch (...) {
89237       {
89238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89239       };
89240     }
89241   }
89242 }
89243
89244
89245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
89246   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89247   Dali::Toolkit::GaussianBlurView arg2 ;
89248   Dali::Toolkit::GaussianBlurView *argp2 ;
89249
89250   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89251   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89252   if (!argp2) {
89253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
89254     return ;
89255   }
89256   arg2 = *argp2;
89257   {
89258     try {
89259       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
89260     } catch (std::out_of_range& e) {
89261       {
89262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89263       };
89264     } catch (std::exception& e) {
89265       {
89266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89267       };
89268     } catch (...) {
89269       {
89270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89271       };
89272     }
89273   }
89274 }
89275
89276
89277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
89278   void * jresult ;
89279   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
89280
89281   {
89282     try {
89283       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
89284     } catch (std::out_of_range& e) {
89285       {
89286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89287       };
89288     } catch (std::exception& e) {
89289       {
89290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89291       };
89292     } catch (...) {
89293       {
89294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89295       };
89296     }
89297   }
89298   jresult = (void *)result;
89299   return jresult;
89300 }
89301
89302
89303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
89304   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89305
89306   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89307   {
89308     try {
89309       delete arg1;
89310     } catch (std::out_of_range& e) {
89311       {
89312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89313       };
89314     } catch (std::exception& e) {
89315       {
89316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89317       };
89318     } catch (...) {
89319       {
89320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89321       };
89322     }
89323   }
89324 }
89325
89326
89327 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
89328   unsigned int jresult ;
89329   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89330   bool result;
89331
89332   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89333   {
89334     try {
89335       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);
89336     } catch (std::out_of_range& e) {
89337       {
89338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89339       };
89340     } catch (std::exception& e) {
89341       {
89342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89343       };
89344     } catch (...) {
89345       {
89346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89347       };
89348     }
89349   }
89350   jresult = result;
89351   return jresult;
89352 }
89353
89354
89355 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
89356   unsigned long jresult ;
89357   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89358   std::size_t result;
89359
89360   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89361   {
89362     try {
89363       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);
89364     } catch (std::out_of_range& e) {
89365       {
89366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89367       };
89368     } catch (std::exception& e) {
89369       {
89370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89371       };
89372     } catch (...) {
89373       {
89374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89375       };
89376     }
89377   }
89378   jresult = (unsigned long)result;
89379   return jresult;
89380 }
89381
89382
89383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
89384   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89385   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89386
89387   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89388   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89389   {
89390     try {
89391       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
89392     } catch (std::out_of_range& e) {
89393       {
89394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89395       };
89396     } catch (std::exception& e) {
89397       {
89398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89399       };
89400     } catch (...) {
89401       {
89402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89403       };
89404     }
89405   }
89406 }
89407
89408
89409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
89410   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89411   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89412
89413   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89414   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89415   {
89416     try {
89417       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89418     } catch (std::out_of_range& e) {
89419       {
89420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89421       };
89422     } catch (std::exception& e) {
89423       {
89424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89425       };
89426     } catch (...) {
89427       {
89428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89429       };
89430     }
89431   }
89432 }
89433
89434
89435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
89436   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89437   Dali::Toolkit::PageTurnView arg2 ;
89438   unsigned int arg3 ;
89439   bool arg4 ;
89440   Dali::Toolkit::PageTurnView *argp2 ;
89441
89442   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89443   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89444   if (!argp2) {
89445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89446     return ;
89447   }
89448   arg2 = *argp2;
89449   arg3 = (unsigned int)jarg3;
89450   arg4 = jarg4 ? true : false;
89451   {
89452     try {
89453       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89454     } catch (std::out_of_range& e) {
89455       {
89456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89457       };
89458     } catch (std::exception& e) {
89459       {
89460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89461       };
89462     } catch (...) {
89463       {
89464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89465       };
89466     }
89467   }
89468 }
89469
89470
89471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
89472   void * jresult ;
89473   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
89474
89475   {
89476     try {
89477       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
89478     } catch (std::out_of_range& e) {
89479       {
89480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89481       };
89482     } catch (std::exception& e) {
89483       {
89484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89485       };
89486     } catch (...) {
89487       {
89488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89489       };
89490     }
89491   }
89492   jresult = (void *)result;
89493   return jresult;
89494 }
89495
89496
89497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
89498   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89499
89500   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89501   {
89502     try {
89503       delete arg1;
89504     } catch (std::out_of_range& e) {
89505       {
89506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89507       };
89508     } catch (std::exception& e) {
89509       {
89510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89511       };
89512     } catch (...) {
89513       {
89514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89515       };
89516     }
89517   }
89518 }
89519
89520
89521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
89522   unsigned int jresult ;
89523   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89524   bool result;
89525
89526   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89527   {
89528     try {
89529       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89530     } catch (std::out_of_range& e) {
89531       {
89532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89533       };
89534     } catch (std::exception& e) {
89535       {
89536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89537       };
89538     } catch (...) {
89539       {
89540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89541       };
89542     }
89543   }
89544   jresult = result;
89545   return jresult;
89546 }
89547
89548
89549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
89550   unsigned long jresult ;
89551   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89552   std::size_t result;
89553
89554   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89555   {
89556     try {
89557       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89558     } catch (std::out_of_range& e) {
89559       {
89560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89561       };
89562     } catch (std::exception& e) {
89563       {
89564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89565       };
89566     } catch (...) {
89567       {
89568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89569       };
89570     }
89571   }
89572   jresult = (unsigned long)result;
89573   return jresult;
89574 }
89575
89576
89577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
89578   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89579   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89580
89581   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89582   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89583   {
89584     try {
89585       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
89586     } catch (std::out_of_range& e) {
89587       {
89588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89589       };
89590     } catch (std::exception& e) {
89591       {
89592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89593       };
89594     } catch (...) {
89595       {
89596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89597       };
89598     }
89599   }
89600 }
89601
89602
89603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
89604   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89605   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89606
89607   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89608   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89609   {
89610     try {
89611       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
89612     } catch (std::out_of_range& e) {
89613       {
89614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89615       };
89616     } catch (std::exception& e) {
89617       {
89618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89619       };
89620     } catch (...) {
89621       {
89622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89623       };
89624     }
89625   }
89626 }
89627
89628
89629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
89630   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89631   Dali::Toolkit::PageTurnView arg2 ;
89632   Dali::Toolkit::PageTurnView *argp2 ;
89633
89634   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89635   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89636   if (!argp2) {
89637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89638     return ;
89639   }
89640   arg2 = *argp2;
89641   {
89642     try {
89643       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
89644     } catch (std::out_of_range& e) {
89645       {
89646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89647       };
89648     } catch (std::exception& e) {
89649       {
89650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89651       };
89652     } catch (...) {
89653       {
89654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89655       };
89656     }
89657   }
89658 }
89659
89660
89661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
89662   void * jresult ;
89663   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
89664
89665   {
89666     try {
89667       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
89668     } catch (std::out_of_range& e) {
89669       {
89670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89671       };
89672     } catch (std::exception& e) {
89673       {
89674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89675       };
89676     } catch (...) {
89677       {
89678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89679       };
89680     }
89681   }
89682   jresult = (void *)result;
89683   return jresult;
89684 }
89685
89686
89687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
89688   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89689
89690   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89691   {
89692     try {
89693       delete arg1;
89694     } catch (std::out_of_range& e) {
89695       {
89696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89697       };
89698     } catch (std::exception& e) {
89699       {
89700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89701       };
89702     } catch (...) {
89703       {
89704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89705       };
89706     }
89707   }
89708 }
89709
89710
89711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
89712   unsigned int jresult ;
89713   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89714   bool result;
89715
89716   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89717   {
89718     try {
89719       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);
89720     } catch (std::out_of_range& e) {
89721       {
89722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89723       };
89724     } catch (std::exception& e) {
89725       {
89726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89727       };
89728     } catch (...) {
89729       {
89730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89731       };
89732     }
89733   }
89734   jresult = result;
89735   return jresult;
89736 }
89737
89738
89739 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
89740   unsigned long jresult ;
89741   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89742   std::size_t result;
89743
89744   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89745   {
89746     try {
89747       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);
89748     } catch (std::out_of_range& e) {
89749       {
89750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89751       };
89752     } catch (std::exception& e) {
89753       {
89754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89755       };
89756     } catch (...) {
89757       {
89758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89759       };
89760     }
89761   }
89762   jresult = (unsigned long)result;
89763   return jresult;
89764 }
89765
89766
89767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
89768   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89769   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
89770
89771   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89772   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
89773   {
89774     try {
89775       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
89776     } catch (std::out_of_range& e) {
89777       {
89778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89779       };
89780     } catch (std::exception& e) {
89781       {
89782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89783       };
89784     } catch (...) {
89785       {
89786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89787       };
89788     }
89789   }
89790 }
89791
89792
89793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89794   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89795   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
89796
89797   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89798   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
89799   {
89800     try {
89801       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
89802     } catch (std::out_of_range& e) {
89803       {
89804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89805       };
89806     } catch (std::exception& e) {
89807       {
89808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89809       };
89810     } catch (...) {
89811       {
89812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89813       };
89814     }
89815   }
89816 }
89817
89818
89819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
89820   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89821   Dali::Toolkit::ProgressBar arg2 ;
89822   float arg3 ;
89823   float arg4 ;
89824   Dali::Toolkit::ProgressBar *argp2 ;
89825
89826   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89827   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
89828   if (!argp2) {
89829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
89830     return ;
89831   }
89832   arg2 = *argp2;
89833   arg3 = (float)jarg3;
89834   arg4 = (float)jarg4;
89835   {
89836     try {
89837       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89838     } catch (std::out_of_range& e) {
89839       {
89840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89841       };
89842     } catch (std::exception& e) {
89843       {
89844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89845       };
89846     } catch (...) {
89847       {
89848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89849       };
89850     }
89851   }
89852 }
89853
89854
89855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
89856   void * jresult ;
89857   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
89858
89859   {
89860     try {
89861       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
89862     } catch (std::out_of_range& e) {
89863       {
89864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89865       };
89866     } catch (std::exception& e) {
89867       {
89868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89869       };
89870     } catch (...) {
89871       {
89872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89873       };
89874     }
89875   }
89876   jresult = (void *)result;
89877   return jresult;
89878 }
89879
89880
89881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
89882   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89883
89884   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89885   {
89886     try {
89887       delete arg1;
89888     } catch (std::out_of_range& e) {
89889       {
89890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89891       };
89892     } catch (std::exception& e) {
89893       {
89894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89895       };
89896     } catch (...) {
89897       {
89898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89899       };
89900     }
89901   }
89902 }
89903
89904
89905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
89906   unsigned int jresult ;
89907   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89908   bool result;
89909
89910   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89911   {
89912     try {
89913       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);
89914     } catch (std::out_of_range& e) {
89915       {
89916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89917       };
89918     } catch (std::exception& e) {
89919       {
89920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89921       };
89922     } catch (...) {
89923       {
89924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89925       };
89926     }
89927   }
89928   jresult = result;
89929   return jresult;
89930 }
89931
89932
89933 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
89934   unsigned long jresult ;
89935   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89936   std::size_t result;
89937
89938   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89939   {
89940     try {
89941       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);
89942     } catch (std::out_of_range& e) {
89943       {
89944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89945       };
89946     } catch (std::exception& e) {
89947       {
89948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89949       };
89950     } catch (...) {
89951       {
89952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89953       };
89954     }
89955   }
89956   jresult = (unsigned long)result;
89957   return jresult;
89958 }
89959
89960
89961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
89962   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89963   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
89964
89965   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89966   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
89967   {
89968     try {
89969       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
89970     } catch (std::out_of_range& e) {
89971       {
89972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89973       };
89974     } catch (std::exception& e) {
89975       {
89976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89977       };
89978     } catch (...) {
89979       {
89980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89981       };
89982     }
89983   }
89984 }
89985
89986
89987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
89988   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
89989   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
89990
89991   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
89992   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
89993   {
89994     try {
89995       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
89996     } catch (std::out_of_range& e) {
89997       {
89998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89999       };
90000     } catch (std::exception& e) {
90001       {
90002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90003       };
90004     } catch (...) {
90005       {
90006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90007       };
90008     }
90009   }
90010 }
90011
90012
90013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
90014   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90015   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
90016
90017   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90018   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
90019   if (!arg2) {
90020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
90021     return ;
90022   }
90023   {
90024     try {
90025       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
90026     } catch (std::out_of_range& e) {
90027       {
90028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90029       };
90030     } catch (std::exception& e) {
90031       {
90032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90033       };
90034     } catch (...) {
90035       {
90036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90037       };
90038     }
90039   }
90040 }
90041
90042
90043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
90044   void * jresult ;
90045   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
90046
90047   {
90048     try {
90049       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
90050     } catch (std::out_of_range& e) {
90051       {
90052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90053       };
90054     } catch (std::exception& e) {
90055       {
90056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90057       };
90058     } catch (...) {
90059       {
90060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90061       };
90062     }
90063   }
90064   jresult = (void *)result;
90065   return jresult;
90066 }
90067
90068
90069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
90070   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90071
90072   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90073   {
90074     try {
90075       delete arg1;
90076     } catch (std::out_of_range& e) {
90077       {
90078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90079       };
90080     } catch (std::exception& e) {
90081       {
90082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90083       };
90084     } catch (...) {
90085       {
90086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90087       };
90088     }
90089   }
90090 }
90091
90092
90093 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
90094   unsigned int jresult ;
90095   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90096   bool result;
90097
90098   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90099   {
90100     try {
90101       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90102     } catch (std::out_of_range& e) {
90103       {
90104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90105       };
90106     } catch (std::exception& e) {
90107       {
90108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90109       };
90110     } catch (...) {
90111       {
90112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90113       };
90114     }
90115   }
90116   jresult = result;
90117   return jresult;
90118 }
90119
90120
90121 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
90122   unsigned long jresult ;
90123   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90124   std::size_t result;
90125
90126   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90127   {
90128     try {
90129       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90130     } catch (std::out_of_range& e) {
90131       {
90132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90133       };
90134     } catch (std::exception& e) {
90135       {
90136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90137       };
90138     } catch (...) {
90139       {
90140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90141       };
90142     }
90143   }
90144   jresult = (unsigned long)result;
90145   return jresult;
90146 }
90147
90148
90149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
90150   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90151   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90152
90153   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90154   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90155   {
90156     try {
90157       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90158     } catch (std::out_of_range& e) {
90159       {
90160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90161       };
90162     } catch (std::exception& e) {
90163       {
90164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90165       };
90166     } catch (...) {
90167       {
90168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90169       };
90170     }
90171   }
90172 }
90173
90174
90175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
90176   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90177   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90178
90179   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90180   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90181   {
90182     try {
90183       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90184     } catch (std::out_of_range& e) {
90185       {
90186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90187       };
90188     } catch (std::exception& e) {
90189       {
90190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90191       };
90192     } catch (...) {
90193       {
90194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90195       };
90196     }
90197   }
90198 }
90199
90200
90201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
90202   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90203   Dali::Vector2 *arg2 = 0 ;
90204
90205   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90206   arg2 = (Dali::Vector2 *)jarg2;
90207   if (!arg2) {
90208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90209     return ;
90210   }
90211   {
90212     try {
90213       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
90214     } catch (std::out_of_range& e) {
90215       {
90216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90217       };
90218     } catch (std::exception& e) {
90219       {
90220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90221       };
90222     } catch (...) {
90223       {
90224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90225       };
90226     }
90227   }
90228 }
90229
90230
90231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
90232   void * jresult ;
90233   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
90234
90235   {
90236     try {
90237       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
90238     } catch (std::out_of_range& e) {
90239       {
90240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90241       };
90242     } catch (std::exception& e) {
90243       {
90244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90245       };
90246     } catch (...) {
90247       {
90248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90249       };
90250     }
90251   }
90252   jresult = (void *)result;
90253   return jresult;
90254 }
90255
90256
90257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
90258   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90259
90260   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90261   {
90262     try {
90263       delete arg1;
90264     } catch (std::out_of_range& e) {
90265       {
90266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90267       };
90268     } catch (std::exception& e) {
90269       {
90270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90271       };
90272     } catch (...) {
90273       {
90274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90275       };
90276     }
90277   }
90278 }
90279
90280
90281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
90282   unsigned int jresult ;
90283   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90284   bool result;
90285
90286   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90287   {
90288     try {
90289       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90290     } catch (std::out_of_range& e) {
90291       {
90292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90293       };
90294     } catch (std::exception& e) {
90295       {
90296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90297       };
90298     } catch (...) {
90299       {
90300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90301       };
90302     }
90303   }
90304   jresult = result;
90305   return jresult;
90306 }
90307
90308
90309 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
90310   unsigned long jresult ;
90311   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90312   std::size_t result;
90313
90314   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90315   {
90316     try {
90317       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90318     } catch (std::out_of_range& e) {
90319       {
90320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90321       };
90322     } catch (std::exception& e) {
90323       {
90324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90325       };
90326     } catch (...) {
90327       {
90328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90329       };
90330     }
90331   }
90332   jresult = (unsigned long)result;
90333   return jresult;
90334 }
90335
90336
90337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
90338   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90339   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90340
90341   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90342   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90343   {
90344     try {
90345       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
90346     } catch (std::out_of_range& e) {
90347       {
90348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90349       };
90350     } catch (std::exception& e) {
90351       {
90352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90353       };
90354     } catch (...) {
90355       {
90356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90357       };
90358     }
90359   }
90360 }
90361
90362
90363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
90364   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90365   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90366
90367   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90368   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90369   {
90370     try {
90371       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
90372     } catch (std::out_of_range& e) {
90373       {
90374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90375       };
90376     } catch (std::exception& e) {
90377       {
90378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90379       };
90380     } catch (...) {
90381       {
90382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90383       };
90384     }
90385   }
90386 }
90387
90388
90389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
90390   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90391   Dali::Toolkit::TextEditor arg2 ;
90392   Dali::Toolkit::TextEditor *argp2 ;
90393
90394   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90395   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
90396   if (!argp2) {
90397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
90398     return ;
90399   }
90400   arg2 = *argp2;
90401   {
90402     try {
90403       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
90404     } catch (std::out_of_range& e) {
90405       {
90406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90407       };
90408     } catch (std::exception& e) {
90409       {
90410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90411       };
90412     } catch (...) {
90413       {
90414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90415       };
90416     }
90417   }
90418 }
90419
90420
90421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
90422   void * jresult ;
90423   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
90424
90425   {
90426     try {
90427       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
90428     } catch (std::out_of_range& e) {
90429       {
90430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90431       };
90432     } catch (std::exception& e) {
90433       {
90434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90435       };
90436     } catch (...) {
90437       {
90438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90439       };
90440     }
90441   }
90442   jresult = (void *)result;
90443   return jresult;
90444 }
90445
90446
90447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
90448   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90449
90450   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90451   {
90452     try {
90453       delete arg1;
90454     } catch (std::out_of_range& e) {
90455       {
90456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90457       };
90458     } catch (std::exception& e) {
90459       {
90460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90461       };
90462     } catch (...) {
90463       {
90464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90465       };
90466     }
90467   }
90468 }
90469
90470
90471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
90472   unsigned int jresult ;
90473   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90474   bool result;
90475
90476   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90477   {
90478     try {
90479       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90480     } catch (std::out_of_range& e) {
90481       {
90482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90483       };
90484     } catch (std::exception& e) {
90485       {
90486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90487       };
90488     } catch (...) {
90489       {
90490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90491       };
90492     }
90493   }
90494   jresult = result;
90495   return jresult;
90496 }
90497
90498
90499 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
90500   unsigned long jresult ;
90501   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90502   std::size_t result;
90503
90504   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90505   {
90506     try {
90507       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90508     } catch (std::out_of_range& e) {
90509       {
90510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90511       };
90512     } catch (std::exception& e) {
90513       {
90514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90515       };
90516     } catch (...) {
90517       {
90518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90519       };
90520     }
90521   }
90522   jresult = (unsigned long)result;
90523   return jresult;
90524 }
90525
90526
90527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
90528   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90529   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90530
90531   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90532   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90533   {
90534     try {
90535       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
90536     } catch (std::out_of_range& e) {
90537       {
90538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90539       };
90540     } catch (std::exception& e) {
90541       {
90542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90543       };
90544     } catch (...) {
90545       {
90546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90547       };
90548     }
90549   }
90550 }
90551
90552
90553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
90554   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90555   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90556
90557   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90558   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90559   {
90560     try {
90561       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
90562     } catch (std::out_of_range& e) {
90563       {
90564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90565       };
90566     } catch (std::exception& e) {
90567       {
90568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90569       };
90570     } catch (...) {
90571       {
90572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90573       };
90574     }
90575   }
90576 }
90577
90578
90579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
90580   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90581   Dali::Toolkit::TextField arg2 ;
90582   Dali::Toolkit::TextField *argp2 ;
90583
90584   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90585   argp2 = (Dali::Toolkit::TextField *)jarg2;
90586   if (!argp2) {
90587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
90588     return ;
90589   }
90590   arg2 = *argp2;
90591   {
90592     try {
90593       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
90594     } catch (std::out_of_range& e) {
90595       {
90596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90597       };
90598     } catch (std::exception& e) {
90599       {
90600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90601       };
90602     } catch (...) {
90603       {
90604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90605       };
90606     }
90607   }
90608 }
90609
90610
90611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
90612   void * jresult ;
90613   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
90614
90615   {
90616     try {
90617       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
90618     } catch (std::out_of_range& e) {
90619       {
90620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90621       };
90622     } catch (std::exception& e) {
90623       {
90624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90625       };
90626     } catch (...) {
90627       {
90628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90629       };
90630     }
90631   }
90632   jresult = (void *)result;
90633   return jresult;
90634 }
90635
90636
90637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
90638   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90639
90640   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90641   {
90642     try {
90643       delete arg1;
90644     } catch (std::out_of_range& e) {
90645       {
90646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90647       };
90648     } catch (std::exception& e) {
90649       {
90650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90651       };
90652     } catch (...) {
90653       {
90654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90655       };
90656     }
90657   }
90658 }
90659
90660
90661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
90662   unsigned int jresult ;
90663   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90664   bool result;
90665
90666   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90667   {
90668     try {
90669       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);
90670     } catch (std::out_of_range& e) {
90671       {
90672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90673       };
90674     } catch (std::exception& e) {
90675       {
90676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90677       };
90678     } catch (...) {
90679       {
90680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90681       };
90682     }
90683   }
90684   jresult = result;
90685   return jresult;
90686 }
90687
90688
90689 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
90690   unsigned long jresult ;
90691   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90692   std::size_t result;
90693
90694   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90695   {
90696     try {
90697       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);
90698     } catch (std::out_of_range& e) {
90699       {
90700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90701       };
90702     } catch (std::exception& e) {
90703       {
90704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90705       };
90706     } catch (...) {
90707       {
90708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90709       };
90710     }
90711   }
90712   jresult = (unsigned long)result;
90713   return jresult;
90714 }
90715
90716
90717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
90718   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90719   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90720
90721   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90722   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90723   {
90724     try {
90725       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90726     } catch (std::out_of_range& e) {
90727       {
90728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90729       };
90730     } catch (std::exception& e) {
90731       {
90732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90733       };
90734     } catch (...) {
90735       {
90736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90737       };
90738     }
90739   }
90740 }
90741
90742
90743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
90744   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90745   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90746
90747   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90748   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90749   {
90750     try {
90751       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90752     } catch (std::out_of_range& e) {
90753       {
90754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90755       };
90756     } catch (std::exception& e) {
90757       {
90758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90759       };
90760     } catch (...) {
90761       {
90762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90763       };
90764     }
90765   }
90766 }
90767
90768
90769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90770   unsigned int jresult ;
90771   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90772   Dali::Toolkit::Control arg2 ;
90773   Dali::KeyEvent *arg3 = 0 ;
90774   Dali::Toolkit::Control *argp2 ;
90775   bool result;
90776
90777   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90778   argp2 = (Dali::Toolkit::Control *)jarg2;
90779   if (!argp2) {
90780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
90781     return 0;
90782   }
90783   arg2 = *argp2;
90784   arg3 = (Dali::KeyEvent *)jarg3;
90785   if (!arg3) {
90786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
90787     return 0;
90788   }
90789   {
90790     try {
90791       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);
90792     } catch (std::out_of_range& e) {
90793       {
90794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90795       };
90796     } catch (std::exception& e) {
90797       {
90798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90799       };
90800     } catch (...) {
90801       {
90802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90803       };
90804     }
90805   }
90806   jresult = result;
90807   return jresult;
90808 }
90809
90810
90811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
90812   void * jresult ;
90813   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
90814
90815   {
90816     try {
90817       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
90818     } catch (std::out_of_range& e) {
90819       {
90820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90821       };
90822     } catch (std::exception& e) {
90823       {
90824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90825       };
90826     } catch (...) {
90827       {
90828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90829       };
90830     }
90831   }
90832   jresult = (void *)result;
90833   return jresult;
90834 }
90835
90836
90837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
90838   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90839
90840   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90841   {
90842     try {
90843       delete arg1;
90844     } catch (std::out_of_range& e) {
90845       {
90846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90847       };
90848     } catch (std::exception& e) {
90849       {
90850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90851       };
90852     } catch (...) {
90853       {
90854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90855       };
90856     }
90857   }
90858 }
90859
90860
90861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
90862   unsigned int jresult ;
90863   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90864   bool result;
90865
90866   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90867   {
90868     try {
90869       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
90870     } catch (std::out_of_range& e) {
90871       {
90872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90873       };
90874     } catch (std::exception& e) {
90875       {
90876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90877       };
90878     } catch (...) {
90879       {
90880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90881       };
90882     }
90883   }
90884   jresult = result;
90885   return jresult;
90886 }
90887
90888
90889 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
90890   unsigned long jresult ;
90891   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90892   std::size_t result;
90893
90894   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90895   {
90896     try {
90897       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
90898     } catch (std::out_of_range& e) {
90899       {
90900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90901       };
90902     } catch (std::exception& e) {
90903       {
90904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90905       };
90906     } catch (...) {
90907       {
90908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90909       };
90910     }
90911   }
90912   jresult = (unsigned long)result;
90913   return jresult;
90914 }
90915
90916
90917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
90918   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90919   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
90920
90921   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90922   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
90923   {
90924     try {
90925       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
90926     } catch (std::out_of_range& e) {
90927       {
90928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90929       };
90930     } catch (std::exception& e) {
90931       {
90932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90933       };
90934     } catch (...) {
90935       {
90936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90937       };
90938     }
90939   }
90940 }
90941
90942
90943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
90944   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90945   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
90946
90947   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90948   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
90949   {
90950     try {
90951       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
90952     } catch (std::out_of_range& e) {
90953       {
90954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90955       };
90956     } catch (std::exception& e) {
90957       {
90958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90959       };
90960     } catch (...) {
90961       {
90962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90963       };
90964     }
90965   }
90966 }
90967
90968
90969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
90970   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
90971   Dali::Toolkit::Control arg2 ;
90972   Dali::Toolkit::Control *argp2 ;
90973
90974   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
90975   argp2 = (Dali::Toolkit::Control *)jarg2;
90976   if (!argp2) {
90977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
90978     return ;
90979   }
90980   arg2 = *argp2;
90981   {
90982     try {
90983       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
90984     } catch (std::out_of_range& e) {
90985       {
90986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90987       };
90988     } catch (std::exception& e) {
90989       {
90990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90991       };
90992     } catch (...) {
90993       {
90994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90995       };
90996     }
90997   }
90998 }
90999
91000
91001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
91002   void * jresult ;
91003   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
91004
91005   {
91006     try {
91007       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
91008     } catch (std::out_of_range& e) {
91009       {
91010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91011       };
91012     } catch (std::exception& e) {
91013       {
91014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91015       };
91016     } catch (...) {
91017       {
91018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91019       };
91020     }
91021   }
91022   jresult = (void *)result;
91023   return jresult;
91024 }
91025
91026
91027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
91028   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91029
91030   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91031   {
91032     try {
91033       delete arg1;
91034     } catch (std::out_of_range& e) {
91035       {
91036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91037       };
91038     } catch (std::exception& e) {
91039       {
91040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91041       };
91042     } catch (...) {
91043       {
91044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91045       };
91046     }
91047   }
91048 }
91049
91050
91051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
91052   unsigned int jresult ;
91053   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91054   bool result;
91055
91056   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91057   {
91058     try {
91059       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91060     } catch (std::out_of_range& e) {
91061       {
91062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91063       };
91064     } catch (std::exception& e) {
91065       {
91066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91067       };
91068     } catch (...) {
91069       {
91070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91071       };
91072     }
91073   }
91074   jresult = result;
91075   return jresult;
91076 }
91077
91078
91079 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
91080   unsigned long jresult ;
91081   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91082   std::size_t result;
91083
91084   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91085   {
91086     try {
91087       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91088     } catch (std::out_of_range& e) {
91089       {
91090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91091       };
91092     } catch (std::exception& e) {
91093       {
91094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91095       };
91096     } catch (...) {
91097       {
91098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91099       };
91100     }
91101   }
91102   jresult = (unsigned long)result;
91103   return jresult;
91104 }
91105
91106
91107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
91108   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91109   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91110
91111   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91112   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91113   {
91114     try {
91115       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
91116     } catch (std::out_of_range& e) {
91117       {
91118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91119       };
91120     } catch (std::exception& e) {
91121       {
91122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91123       };
91124     } catch (...) {
91125       {
91126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91127       };
91128     }
91129   }
91130 }
91131
91132
91133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
91134   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91135   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91136
91137   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91138   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91139   {
91140     try {
91141       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
91142     } catch (std::out_of_range& e) {
91143       {
91144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91145       };
91146     } catch (std::exception& e) {
91147       {
91148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91149       };
91150     } catch (...) {
91151       {
91152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91153       };
91154     }
91155   }
91156 }
91157
91158
91159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
91160   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91161   Dali::Toolkit::VideoView *arg2 = 0 ;
91162
91163   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91164   arg2 = (Dali::Toolkit::VideoView *)jarg2;
91165   if (!arg2) {
91166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
91167     return ;
91168   }
91169   {
91170     try {
91171       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
91172     } catch (std::out_of_range& e) {
91173       {
91174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91175       };
91176     } catch (std::exception& e) {
91177       {
91178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91179       };
91180     } catch (...) {
91181       {
91182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91183       };
91184     }
91185   }
91186 }
91187
91188
91189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
91190   void * jresult ;
91191   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
91192
91193   {
91194     try {
91195       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
91196     } catch (std::out_of_range& e) {
91197       {
91198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91199       };
91200     } catch (std::exception& e) {
91201       {
91202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91203       };
91204     } catch (...) {
91205       {
91206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91207       };
91208     }
91209   }
91210   jresult = (void *)result;
91211   return jresult;
91212 }
91213
91214
91215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
91216   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91217
91218   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91219   {
91220     try {
91221       delete arg1;
91222     } catch (std::out_of_range& e) {
91223       {
91224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91225       };
91226     } catch (std::exception& e) {
91227       {
91228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91229       };
91230     } catch (...) {
91231       {
91232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91233       };
91234     }
91235   }
91236 }
91237
91238
91239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
91240   unsigned int jresult ;
91241   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91242   bool result;
91243
91244   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91245   {
91246     try {
91247       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91248     } catch (std::out_of_range& e) {
91249       {
91250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91251       };
91252     } catch (std::exception& e) {
91253       {
91254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91255       };
91256     } catch (...) {
91257       {
91258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91259       };
91260     }
91261   }
91262   jresult = result;
91263   return jresult;
91264 }
91265
91266
91267 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
91268   unsigned long jresult ;
91269   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91270   std::size_t result;
91271
91272   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91273   {
91274     try {
91275       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91276     } catch (std::out_of_range& e) {
91277       {
91278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91279       };
91280     } catch (std::exception& e) {
91281       {
91282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91283       };
91284     } catch (...) {
91285       {
91286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91287       };
91288     }
91289   }
91290   jresult = (unsigned long)result;
91291   return jresult;
91292 }
91293
91294
91295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91296   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91297   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91298
91299   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91300   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91301   {
91302     try {
91303       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
91304     } catch (std::out_of_range& e) {
91305       {
91306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91307       };
91308     } catch (std::exception& e) {
91309       {
91310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91311       };
91312     } catch (...) {
91313       {
91314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91315       };
91316     }
91317   }
91318 }
91319
91320
91321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91322   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91323   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91324
91325   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91326   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91327   {
91328     try {
91329       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91330     } catch (std::out_of_range& e) {
91331       {
91332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91333       };
91334     } catch (std::exception& e) {
91335       {
91336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91337       };
91338     } catch (...) {
91339       {
91340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91341       };
91342     }
91343   }
91344 }
91345
91346
91347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
91348   unsigned int jresult ;
91349   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91350   Dali::Toolkit::Slider arg2 ;
91351   float arg3 ;
91352   Dali::Toolkit::Slider *argp2 ;
91353   bool result;
91354
91355   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91356   argp2 = (Dali::Toolkit::Slider *)jarg2;
91357   if (!argp2) {
91358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91359     return 0;
91360   }
91361   arg2 = *argp2;
91362   arg3 = (float)jarg3;
91363   {
91364     try {
91365       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
91366     } catch (std::out_of_range& e) {
91367       {
91368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91369       };
91370     } catch (std::exception& e) {
91371       {
91372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91373       };
91374     } catch (...) {
91375       {
91376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91377       };
91378     }
91379   }
91380   jresult = result;
91381   return jresult;
91382 }
91383
91384
91385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
91386   void * jresult ;
91387   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
91388
91389   {
91390     try {
91391       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
91392     } catch (std::out_of_range& e) {
91393       {
91394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91395       };
91396     } catch (std::exception& e) {
91397       {
91398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91399       };
91400     } catch (...) {
91401       {
91402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91403       };
91404     }
91405   }
91406   jresult = (void *)result;
91407   return jresult;
91408 }
91409
91410
91411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
91412   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91413
91414   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91415   {
91416     try {
91417       delete arg1;
91418     } catch (std::out_of_range& e) {
91419       {
91420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91421       };
91422     } catch (std::exception& e) {
91423       {
91424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91425       };
91426     } catch (...) {
91427       {
91428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91429       };
91430     }
91431   }
91432 }
91433
91434
91435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
91436   unsigned int jresult ;
91437   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91438   bool result;
91439
91440   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91441   {
91442     try {
91443       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91444     } catch (std::out_of_range& e) {
91445       {
91446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91447       };
91448     } catch (std::exception& e) {
91449       {
91450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91451       };
91452     } catch (...) {
91453       {
91454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91455       };
91456     }
91457   }
91458   jresult = result;
91459   return jresult;
91460 }
91461
91462
91463 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
91464   unsigned long jresult ;
91465   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91466   std::size_t result;
91467
91468   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91469   {
91470     try {
91471       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91472     } catch (std::out_of_range& e) {
91473       {
91474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91475       };
91476     } catch (std::exception& e) {
91477       {
91478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91479       };
91480     } catch (...) {
91481       {
91482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91483       };
91484     }
91485   }
91486   jresult = (unsigned long)result;
91487   return jresult;
91488 }
91489
91490
91491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
91492   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91493   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91494
91495   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91496   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91497   {
91498     try {
91499       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
91500     } catch (std::out_of_range& e) {
91501       {
91502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91503       };
91504     } catch (std::exception& e) {
91505       {
91506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91507       };
91508     } catch (...) {
91509       {
91510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91511       };
91512     }
91513   }
91514 }
91515
91516
91517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
91518   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91519   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91520
91521   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91522   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91523   {
91524     try {
91525       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
91526     } catch (std::out_of_range& e) {
91527       {
91528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91529       };
91530     } catch (std::exception& e) {
91531       {
91532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91533       };
91534     } catch (...) {
91535       {
91536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91537       };
91538     }
91539   }
91540 }
91541
91542
91543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91544   unsigned int jresult ;
91545   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91546   Dali::Toolkit::Slider arg2 ;
91547   int arg3 ;
91548   Dali::Toolkit::Slider *argp2 ;
91549   bool result;
91550
91551   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91552   argp2 = (Dali::Toolkit::Slider *)jarg2;
91553   if (!argp2) {
91554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91555     return 0;
91556   }
91557   arg2 = *argp2;
91558   arg3 = (int)jarg3;
91559   {
91560     try {
91561       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
91562     } catch (std::out_of_range& e) {
91563       {
91564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91565       };
91566     } catch (std::exception& e) {
91567       {
91568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91569       };
91570     } catch (...) {
91571       {
91572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91573       };
91574     }
91575   }
91576   jresult = result;
91577   return jresult;
91578 }
91579
91580
91581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
91582   void * jresult ;
91583   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
91584
91585   {
91586     try {
91587       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
91588     } catch (std::out_of_range& e) {
91589       {
91590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91591       };
91592     } catch (std::exception& e) {
91593       {
91594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91595       };
91596     } catch (...) {
91597       {
91598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91599       };
91600     }
91601   }
91602   jresult = (void *)result;
91603   return jresult;
91604 }
91605
91606
91607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
91608   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91609
91610   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91611   {
91612     try {
91613       delete arg1;
91614     } catch (std::out_of_range& e) {
91615       {
91616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91617       };
91618     } catch (std::exception& e) {
91619       {
91620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91621       };
91622     } catch (...) {
91623       {
91624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91625       };
91626     }
91627   }
91628 }
91629
91630
91631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
91632   void * jresult ;
91633   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91634
91635   {
91636     try {
91637       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
91638     } catch (std::out_of_range& e) {
91639       {
91640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91641       };
91642     } catch (std::exception& e) {
91643       {
91644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91645       };
91646     } catch (...) {
91647       {
91648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91649       };
91650     }
91651   }
91652   jresult = (void *)result;
91653   return jresult;
91654 }
91655
91656
91657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
91658   void * jresult ;
91659   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
91660   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91661
91662   arg1 = (Dali::Toolkit::Ruler *)jarg1;
91663   {
91664     try {
91665       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
91666     } catch (std::out_of_range& e) {
91667       {
91668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91669       };
91670     } catch (std::exception& e) {
91671       {
91672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91673       };
91674     } catch (...) {
91675       {
91676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91677       };
91678     }
91679   }
91680   jresult = (void *)result;
91681   return jresult;
91682 }
91683
91684
91685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
91686   void * jresult ;
91687   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
91688   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91689
91690   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91691   if (!arg1) {
91692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91693     return 0;
91694   }
91695   {
91696     try {
91697       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
91698     } catch (std::out_of_range& e) {
91699       {
91700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91701       };
91702     } catch (std::exception& e) {
91703       {
91704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91705       };
91706     } catch (...) {
91707       {
91708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91709       };
91710     }
91711   }
91712   jresult = (void *)result;
91713   return jresult;
91714 }
91715
91716
91717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
91718   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91719
91720   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91721   {
91722     try {
91723       delete arg1;
91724     } catch (std::out_of_range& e) {
91725       {
91726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91727       };
91728     } catch (std::exception& e) {
91729       {
91730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91731       };
91732     } catch (...) {
91733       {
91734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91735       };
91736     }
91737   }
91738 }
91739
91740
91741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
91742   void * jresult ;
91743   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91744   Dali::Toolkit::Ruler *result = 0 ;
91745
91746   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91747   {
91748     try {
91749       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
91750     } catch (std::out_of_range& e) {
91751       {
91752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91753       };
91754     } catch (std::exception& e) {
91755       {
91756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91757       };
91758     } catch (...) {
91759       {
91760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91761       };
91762     }
91763   }
91764   jresult = (void *)result;
91765   return jresult;
91766 }
91767
91768
91769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
91770   void * jresult ;
91771   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91772   Dali::Toolkit::Ruler *result = 0 ;
91773
91774   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91775   {
91776     try {
91777       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
91778     } catch (std::out_of_range& e) {
91779       {
91780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91781       };
91782     } catch (std::exception& e) {
91783       {
91784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91785       };
91786     } catch (...) {
91787       {
91788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91789       };
91790     }
91791   }
91792   jresult = (void *)result;
91793   return jresult;
91794 }
91795
91796
91797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
91798   void * jresult ;
91799   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91800   Dali::Toolkit::Ruler *result = 0 ;
91801
91802   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91803   {
91804     try {
91805       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
91806     } catch (std::out_of_range& e) {
91807       {
91808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91809       };
91810     } catch (std::exception& e) {
91811       {
91812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91813       };
91814     } catch (...) {
91815       {
91816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91817       };
91818     }
91819   }
91820   jresult = (void *)result;
91821   return jresult;
91822 }
91823
91824
91825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
91826   void * jresult ;
91827   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91828   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
91829   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91830
91831   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91832   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
91833   if (!arg2) {
91834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91835     return 0;
91836   }
91837   {
91838     try {
91839       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
91840     } catch (std::out_of_range& e) {
91841       {
91842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91843       };
91844     } catch (std::exception& e) {
91845       {
91846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91847       };
91848     } catch (...) {
91849       {
91850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91851       };
91852     }
91853   }
91854   jresult = (void *)result;
91855   return jresult;
91856 }
91857
91858
91859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
91860   void * jresult ;
91861   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91862   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
91863   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91864
91865   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91866   arg2 = (Dali::Toolkit::Ruler *)jarg2;
91867   {
91868     try {
91869       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
91870     } catch (std::out_of_range& e) {
91871       {
91872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91873       };
91874     } catch (std::exception& e) {
91875       {
91876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91877       };
91878     } catch (...) {
91879       {
91880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91881       };
91882     }
91883   }
91884   jresult = (void *)result;
91885   return jresult;
91886 }
91887
91888
91889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
91890   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91891
91892   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91893   {
91894     try {
91895       (arg1)->Reset();
91896     } catch (std::out_of_range& e) {
91897       {
91898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91899       };
91900     } catch (std::exception& e) {
91901       {
91902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91903       };
91904     } catch (...) {
91905       {
91906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91907       };
91908     }
91909   }
91910 }
91911
91912
91913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
91914   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91915   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
91916
91917   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91918   arg2 = (Dali::Toolkit::Ruler *)jarg2;
91919   {
91920     try {
91921       (arg1)->Reset(arg2);
91922     } catch (std::out_of_range& e) {
91923       {
91924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91925       };
91926     } catch (std::exception& e) {
91927       {
91928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91929       };
91930     } catch (...) {
91931       {
91932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91933       };
91934     }
91935   }
91936 }
91937
91938
91939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
91940   void * jresult ;
91941   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91942   Dali::Toolkit::Ruler *result = 0 ;
91943
91944   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91945   {
91946     try {
91947       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
91948     } catch (std::out_of_range& e) {
91949       {
91950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91951       };
91952     } catch (std::exception& e) {
91953       {
91954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91955       };
91956     } catch (...) {
91957       {
91958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91959       };
91960     }
91961   }
91962   jresult = (void *)result;
91963   return jresult;
91964 }
91965
91966
91967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
91968   float jresult ;
91969   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91970   float arg2 ;
91971   float arg3 ;
91972   float result;
91973
91974   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91975   arg2 = (float)jarg2;
91976   arg3 = (float)jarg3;
91977   {
91978     try {
91979       result = (float)(*arg1)->Snap(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 (...) {
91989       {
91990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91991       };
91992     }
91993   }
91994   jresult = result;
91995   return jresult;
91996 }
91997
91998
91999 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
92000   float jresult ;
92001   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92002   float arg2 ;
92003   float result;
92004
92005   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92006   arg2 = (float)jarg2;
92007   {
92008     try {
92009       result = (float)(*arg1)->Snap(arg2);
92010     } catch (std::out_of_range& e) {
92011       {
92012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92013       };
92014     } catch (std::exception& e) {
92015       {
92016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92017       };
92018     } catch (...) {
92019       {
92020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92021       };
92022     }
92023   }
92024   jresult = result;
92025   return jresult;
92026 }
92027
92028
92029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
92030   float jresult ;
92031   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92032   unsigned int arg2 ;
92033   unsigned int *arg3 = 0 ;
92034   bool arg4 ;
92035   float result;
92036
92037   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92038   arg2 = (unsigned int)jarg2;
92039   arg3 = (unsigned int *)jarg3;
92040   arg4 = jarg4 ? true : false;
92041   {
92042     try {
92043       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
92044     } catch (std::out_of_range& e) {
92045       {
92046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92047       };
92048     } catch (std::exception& e) {
92049       {
92050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92051       };
92052     } catch (...) {
92053       {
92054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92055       };
92056     }
92057   }
92058   jresult = result;
92059   return jresult;
92060 }
92061
92062
92063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
92064   unsigned int jresult ;
92065   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92066   float arg2 ;
92067   bool arg3 ;
92068   unsigned int result;
92069
92070   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92071   arg2 = (float)jarg2;
92072   arg3 = jarg3 ? true : false;
92073   {
92074     try {
92075       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
92076     } catch (std::out_of_range& e) {
92077       {
92078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92079       };
92080     } catch (std::exception& e) {
92081       {
92082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92083       };
92084     } catch (...) {
92085       {
92086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92087       };
92088     }
92089   }
92090   jresult = result;
92091   return jresult;
92092 }
92093
92094
92095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
92096   unsigned int jresult ;
92097   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92098   unsigned int result;
92099
92100   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92101   {
92102     try {
92103       result = (unsigned int)(*arg1)->GetTotalPages();
92104     } catch (std::out_of_range& e) {
92105       {
92106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92107       };
92108     } catch (std::exception& e) {
92109       {
92110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92111       };
92112     } catch (...) {
92113       {
92114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92115       };
92116     }
92117   }
92118   jresult = result;
92119   return jresult;
92120 }
92121
92122
92123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
92124   int jresult ;
92125   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92126   Dali::Toolkit::Ruler::RulerType result;
92127
92128   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92129   {
92130     try {
92131       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
92132     } catch (std::out_of_range& e) {
92133       {
92134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92135       };
92136     } catch (std::exception& e) {
92137       {
92138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92139       };
92140     } catch (...) {
92141       {
92142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92143       };
92144     }
92145   }
92146   jresult = (int)result;
92147   return jresult;
92148 }
92149
92150
92151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
92152   unsigned int jresult ;
92153   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92154   bool result;
92155
92156   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92157   {
92158     try {
92159       result = (bool)(*arg1)->IsEnabled();
92160     } catch (std::out_of_range& e) {
92161       {
92162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92163       };
92164     } catch (std::exception& e) {
92165       {
92166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92167       };
92168     } catch (...) {
92169       {
92170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92171       };
92172     }
92173   }
92174   jresult = result;
92175   return jresult;
92176 }
92177
92178
92179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
92180   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92181
92182   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92183   {
92184     try {
92185       (*arg1)->Enable();
92186     } catch (std::out_of_range& e) {
92187       {
92188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92189       };
92190     } catch (std::exception& e) {
92191       {
92192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92193       };
92194     } catch (...) {
92195       {
92196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92197       };
92198     }
92199   }
92200 }
92201
92202
92203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
92204   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92205
92206   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92207   {
92208     try {
92209       (*arg1)->Disable();
92210     } catch (std::out_of_range& e) {
92211       {
92212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92213       };
92214     } catch (std::exception& e) {
92215       {
92216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92217       };
92218     } catch (...) {
92219       {
92220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92221       };
92222     }
92223   }
92224 }
92225
92226
92227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
92228   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92229   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
92230   Dali::Toolkit::RulerDomain *argp2 ;
92231
92232   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92233   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
92234   if (!argp2) {
92235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
92236     return ;
92237   }
92238   arg2 = *argp2;
92239   {
92240     try {
92241       (*arg1)->SetDomain(arg2);
92242     } catch (std::out_of_range& e) {
92243       {
92244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92245       };
92246     } catch (std::exception& e) {
92247       {
92248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92249       };
92250     } catch (...) {
92251       {
92252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92253       };
92254     }
92255   }
92256 }
92257
92258
92259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
92260   void * jresult ;
92261   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92262   Dali::Toolkit::RulerDomain *result = 0 ;
92263
92264   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92265   {
92266     try {
92267       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
92268     } catch (std::out_of_range& e) {
92269       {
92270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92271       };
92272     } catch (std::exception& e) {
92273       {
92274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92275       };
92276     } catch (...) {
92277       {
92278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92279       };
92280     }
92281   }
92282   jresult = (void *)result;
92283   return jresult;
92284 }
92285
92286
92287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
92288   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92289
92290   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92291   {
92292     try {
92293       (*arg1)->DisableDomain();
92294     } catch (std::out_of_range& e) {
92295       {
92296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92297       };
92298     } catch (std::exception& e) {
92299       {
92300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92301       };
92302     } catch (...) {
92303       {
92304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92305       };
92306     }
92307   }
92308 }
92309
92310
92311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
92312   float jresult ;
92313   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92314   float arg2 ;
92315   float arg3 ;
92316   float arg4 ;
92317   float result;
92318
92319   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92320   arg2 = (float)jarg2;
92321   arg3 = (float)jarg3;
92322   arg4 = (float)jarg4;
92323   {
92324     try {
92325       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
92326     } catch (std::out_of_range& e) {
92327       {
92328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92329       };
92330     } catch (std::exception& e) {
92331       {
92332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92333       };
92334     } catch (...) {
92335       {
92336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92337       };
92338     }
92339   }
92340   jresult = result;
92341   return jresult;
92342 }
92343
92344
92345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
92346   float jresult ;
92347   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92348   float arg2 ;
92349   float arg3 ;
92350   float result;
92351
92352   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92353   arg2 = (float)jarg2;
92354   arg3 = (float)jarg3;
92355   {
92356     try {
92357       result = (float)(*arg1)->Clamp(arg2,arg3);
92358     } catch (std::out_of_range& e) {
92359       {
92360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92361       };
92362     } catch (std::exception& e) {
92363       {
92364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92365       };
92366     } catch (...) {
92367       {
92368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92369       };
92370     }
92371   }
92372   jresult = result;
92373   return jresult;
92374 }
92375
92376
92377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
92378   float jresult ;
92379   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92380   float arg2 ;
92381   float result;
92382
92383   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92384   arg2 = (float)jarg2;
92385   {
92386     try {
92387       result = (float)(*arg1)->Clamp(arg2);
92388     } catch (std::out_of_range& e) {
92389       {
92390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92391       };
92392     } catch (std::exception& e) {
92393       {
92394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92395       };
92396     } catch (...) {
92397       {
92398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92399       };
92400     }
92401   }
92402   jresult = result;
92403   return jresult;
92404 }
92405
92406
92407 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
92408   float jresult ;
92409   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92410   float arg2 ;
92411   float arg3 ;
92412   float arg4 ;
92413   Dali::Toolkit::ClampState *arg5 = 0 ;
92414   float result;
92415
92416   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92417   arg2 = (float)jarg2;
92418   arg3 = (float)jarg3;
92419   arg4 = (float)jarg4;
92420   arg5 = (Dali::Toolkit::ClampState *)jarg5;
92421   if (!arg5) {
92422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92423     return 0;
92424   }
92425   {
92426     try {
92427       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
92428     } catch (std::out_of_range& e) {
92429       {
92430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92431       };
92432     } catch (std::exception& e) {
92433       {
92434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92435       };
92436     } catch (...) {
92437       {
92438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92439       };
92440     }
92441   }
92442   jresult = result;
92443   return jresult;
92444 }
92445
92446
92447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
92448   float jresult ;
92449   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92450   float arg2 ;
92451   float arg3 ;
92452   float arg4 ;
92453   float arg5 ;
92454   float result;
92455
92456   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92457   arg2 = (float)jarg2;
92458   arg3 = (float)jarg3;
92459   arg4 = (float)jarg4;
92460   arg5 = (float)jarg5;
92461   {
92462     try {
92463       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
92464     } catch (std::out_of_range& e) {
92465       {
92466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92467       };
92468     } catch (std::exception& e) {
92469       {
92470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92471       };
92472     } catch (...) {
92473       {
92474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92475       };
92476     }
92477   }
92478   jresult = result;
92479   return jresult;
92480 }
92481
92482
92483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
92484   float jresult ;
92485   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92486   float arg2 ;
92487   float arg3 ;
92488   float arg4 ;
92489   float result;
92490
92491   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92492   arg2 = (float)jarg2;
92493   arg3 = (float)jarg3;
92494   arg4 = (float)jarg4;
92495   {
92496     try {
92497       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
92498     } catch (std::out_of_range& e) {
92499       {
92500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92501       };
92502     } catch (std::exception& e) {
92503       {
92504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92505       };
92506     } catch (...) {
92507       {
92508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92509       };
92510     }
92511   }
92512   jresult = result;
92513   return jresult;
92514 }
92515
92516
92517 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
92518   float jresult ;
92519   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92520   float arg2 ;
92521   float arg3 ;
92522   float result;
92523
92524   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92525   arg2 = (float)jarg2;
92526   arg3 = (float)jarg3;
92527   {
92528     try {
92529       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
92530     } catch (std::out_of_range& e) {
92531       {
92532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92533       };
92534     } catch (std::exception& e) {
92535       {
92536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92537       };
92538     } catch (...) {
92539       {
92540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92541       };
92542     }
92543   }
92544   jresult = result;
92545   return jresult;
92546 }
92547
92548
92549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
92550   float jresult ;
92551   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92552   float arg2 ;
92553   float result;
92554
92555   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92556   arg2 = (float)jarg2;
92557   {
92558     try {
92559       result = (float)(*arg1)->SnapAndClamp(arg2);
92560     } catch (std::out_of_range& e) {
92561       {
92562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92563       };
92564     } catch (std::exception& e) {
92565       {
92566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92567       };
92568     } catch (...) {
92569       {
92570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92571       };
92572     }
92573   }
92574   jresult = result;
92575   return jresult;
92576 }
92577
92578
92579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
92580   float jresult ;
92581   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92582   float arg2 ;
92583   float arg3 ;
92584   float arg4 ;
92585   float arg5 ;
92586   Dali::Toolkit::ClampState *arg6 = 0 ;
92587   float result;
92588
92589   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92590   arg2 = (float)jarg2;
92591   arg3 = (float)jarg3;
92592   arg4 = (float)jarg4;
92593   arg5 = (float)jarg5;
92594   arg6 = (Dali::Toolkit::ClampState *)jarg6;
92595   if (!arg6) {
92596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92597     return 0;
92598   }
92599   {
92600     try {
92601       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
92602     } catch (std::out_of_range& e) {
92603       {
92604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92605       };
92606     } catch (std::exception& e) {
92607       {
92608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92609       };
92610     } catch (...) {
92611       {
92612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92613       };
92614     }
92615   }
92616   jresult = result;
92617   return jresult;
92618 }
92619
92620
92621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
92622   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92623
92624   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92625   {
92626     try {
92627       (*arg1)->Reference();
92628     } catch (std::out_of_range& e) {
92629       {
92630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92631       };
92632     } catch (std::exception& e) {
92633       {
92634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92635       };
92636     } catch (...) {
92637       {
92638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92639       };
92640     }
92641   }
92642 }
92643
92644
92645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
92646   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92647
92648   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92649   {
92650     try {
92651       (*arg1)->Unreference();
92652     } catch (std::out_of_range& e) {
92653       {
92654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92655       };
92656     } catch (std::exception& e) {
92657       {
92658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92659       };
92660     } catch (...) {
92661       {
92662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92663       };
92664     }
92665   }
92666 }
92667
92668
92669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
92670   int jresult ;
92671   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92672   int result;
92673
92674   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92675   {
92676     try {
92677       result = (int)(*arg1)->ReferenceCount();
92678     } catch (std::out_of_range& e) {
92679       {
92680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92681       };
92682     } catch (std::exception& e) {
92683       {
92684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92685       };
92686     } catch (...) {
92687       {
92688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92689       };
92690     }
92691   }
92692   jresult = result;
92693   return jresult;
92694 }
92695
92696
92697 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
92698     return (Dali::RefObject *)jarg1;
92699 }
92700
92701 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
92702     return (Dali::SignalObserver *)jarg1;
92703 }
92704
92705 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
92706     return (Dali::ConnectionTrackerInterface *)jarg1;
92707 }
92708
92709 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
92710     return (Dali::BaseHandle *)jarg1;
92711 }
92712
92713 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
92714     return (Dali::BaseHandle *)jarg1;
92715 }
92716
92717 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
92718     return (Dali::BaseHandle *)jarg1;
92719 }
92720
92721 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
92722     return (Dali::BaseHandle *)jarg1;
92723 }
92724
92725 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
92726     return (Dali::BaseHandle *)jarg1;
92727 }
92728
92729 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
92730     return (Dali::BaseHandle *)jarg1;
92731 }
92732
92733 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
92734     return (Dali::BaseHandle *)jarg1;
92735 }
92736
92737 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
92738     return (Dali::BaseHandle *)jarg1;
92739 }
92740
92741 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
92742     return (Dali::BaseHandle *)jarg1;
92743 }
92744
92745 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
92746     return (Dali::BaseHandle *)jarg1;
92747 }
92748
92749 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
92750     return (Dali::BaseHandle *)jarg1;
92751 }
92752
92753 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
92754     return (Dali::BaseHandle *)jarg1;
92755 }
92756
92757 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
92758     return (Dali::BaseHandle *)jarg1;
92759 }
92760
92761 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
92762     return (Dali::Handle *)jarg1;
92763 }
92764
92765 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
92766     return (Dali::Handle *)jarg1;
92767 }
92768
92769 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
92770     return (Dali::BaseHandle *)jarg1;
92771 }
92772
92773 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
92774     return (Dali::BaseHandle *)jarg1;
92775 }
92776
92777 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
92778     return (Dali::Handle *)jarg1;
92779 }
92780
92781 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
92782     return (Dali::BaseHandle *)jarg1;
92783 }
92784
92785 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
92786     return (Dali::Handle *)jarg1;
92787 }
92788
92789 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
92790     return (Dali::GestureDetector *)jarg1;
92791 }
92792
92793 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
92794     return (Dali::Gesture *)jarg1;
92795 }
92796
92797 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
92798     return (Dali::Handle *)jarg1;
92799 }
92800
92801 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
92802     return (Dali::Actor *)jarg1;
92803 }
92804
92805 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
92806     return (Dali::BaseHandle *)jarg1;
92807 }
92808
92809 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
92810     return (Dali::RefObject *)jarg1;
92811 }
92812
92813 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
92814     return (Dali::Actor *)jarg1;
92815 }
92816
92817 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
92818     return (Dali::GestureDetector *)jarg1;
92819 }
92820
92821 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
92822     return (Dali::Gesture *)jarg1;
92823 }
92824
92825 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
92826     return (Dali::GestureDetector *)jarg1;
92827 }
92828
92829 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
92830     return (Dali::Gesture *)jarg1;
92831 }
92832
92833 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
92834     return (Dali::GestureDetector *)jarg1;
92835 }
92836
92837 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
92838     return (Dali::Gesture *)jarg1;
92839 }
92840
92841 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
92842     return (Dali::BaseHandle *)jarg1;
92843 }
92844
92845 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
92846     return (Dali::Handle *)jarg1;
92847 }
92848
92849 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
92850     return (Dali::BaseHandle *)jarg1;
92851 }
92852
92853 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
92854     return (Dali::Handle *)jarg1;
92855 }
92856
92857 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
92858     return (Dali::Handle *)jarg1;
92859 }
92860
92861 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
92862     return (Dali::Image *)jarg1;
92863 }
92864
92865 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
92866     return (Dali::Image *)jarg1;
92867 }
92868
92869 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
92870     return (Dali::Image *)jarg1;
92871 }
92872
92873 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
92874     return (Dali::RefObject *)jarg1;
92875 }
92876
92877 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
92878     return (Dali::Image *)jarg1;
92879 }
92880
92881 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
92882     return (Dali::Image *)jarg1;
92883 }
92884
92885 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
92886     return (Dali::ResourceImage *)jarg1;
92887 }
92888
92889 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
92890     return (Dali::Actor *)jarg1;
92891 }
92892
92893 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
92894     return (Dali::BaseHandle *)jarg1;
92895 }
92896
92897 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
92898     return (Dali::BaseHandle *)jarg1;
92899 }
92900
92901 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
92902     return (Dali::BaseHandle *)jarg1;
92903 }
92904
92905 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
92906     return (Dali::BaseHandle *)jarg1;
92907 }
92908
92909 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
92910     return (Dali::BaseHandle *)jarg1;
92911 }
92912
92913 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
92914     return (Dali::BaseHandle *)jarg1;
92915 }
92916
92917 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
92918     return (Dali::CustomActorImpl *)jarg1;
92919 }
92920
92921 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
92922     return (Dali::CustomActor *)jarg1;
92923 }
92924
92925 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
92926     return (Dali::BaseHandle *)jarg1;
92927 }
92928
92929 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
92930     return (Dali::Toolkit::Control *)jarg1;
92931 }
92932
92933 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
92934     return (Dali::Toolkit::Control *)jarg1;
92935 }
92936
92937 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
92938     return (Dali::Toolkit::Button *)jarg1;
92939 }
92940
92941 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
92942     return (Dali::Toolkit::Button *)jarg1;
92943 }
92944
92945 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
92946     return (Dali::Toolkit::Button *)jarg1;
92947 }
92948
92949 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
92950     return (Dali::Toolkit::Control *)jarg1;
92951 }
92952
92953 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
92954     return (Dali::Toolkit::Control *)jarg1;
92955 }
92956
92957 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
92958     return (Dali::Toolkit::Control *)jarg1;
92959 }
92960
92961 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
92962     return (Dali::Toolkit::Control *)jarg1;
92963 }
92964
92965 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
92966     return (Dali::Toolkit::Control *)jarg1;
92967 }
92968
92969 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
92970     return (Dali::RefObject *)jarg1;
92971 }
92972
92973 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
92974     return (Dali::Toolkit::Scrollable *)jarg1;
92975 }
92976
92977 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
92978     return (Dali::BaseHandle *)jarg1;
92979 }
92980
92981 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
92982     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
92983 }
92984
92985 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
92986     return (Dali::RefObject *)jarg1;
92987 }
92988
92989 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
92990     return (Dali::Toolkit::Ruler *)jarg1;
92991 }
92992
92993 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
92994     return (Dali::Toolkit::Ruler *)jarg1;
92995 }
92996
92997 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
92998     return (Dali::Toolkit::Scrollable *)jarg1;
92999 }
93000
93001 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
93002     return (Dali::Toolkit::Control *)jarg1;
93003 }
93004
93005 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
93006     return (Dali::Toolkit::Control *)jarg1;
93007 }
93008
93009 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
93010     return (Dali::Toolkit::Control *)jarg1;
93011 }
93012
93013 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
93014     return (Dali::Toolkit::Control *)jarg1;
93015 }
93016
93017 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
93018     return (Dali::BaseHandle *)jarg1;
93019 }
93020
93021 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
93022     return (Dali::BaseHandle *)jarg1;
93023 }
93024
93025 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
93026     return (Dali::Toolkit::Control *)jarg1;
93027 }
93028
93029 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
93030     return (Dali::Toolkit::Control *)jarg1;
93031 }
93032
93033 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
93034     return (Dali::Toolkit::Control *)jarg1;
93035 }
93036
93037 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
93038     return (Dali::Toolkit::Control *)jarg1;
93039 }
93040
93041 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
93042     return (Dali::Toolkit::Control *)jarg1;
93043 }
93044
93045 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
93046     return (Dali::Toolkit::Control *)jarg1;
93047 }
93048
93049 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
93050     return (Dali::Toolkit::PageTurnView *)jarg1;
93051 }
93052
93053 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
93054     return (Dali::Toolkit::PageTurnView *)jarg1;
93055 }
93056
93057 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
93058     return (Dali::Toolkit::Button *)jarg1;
93059 }
93060
93061 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
93062     return (Dali::BaseHandle *)jarg1;
93063 }
93064
93065 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
93066     return (Dali::BaseHandle *)jarg1;
93067 }
93068
93069 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
93070     return (Dali::BaseHandle *)jarg1;
93071 }
93072
93073 #ifdef __cplusplus
93074 }
93075 #endif
93076