dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11
  12 #ifndef SWIGCSHARP
  13 #define SWIGCSHARP
  14 #endif
  15
  16 #define SWIG_DIRECTORS
  17
  18
  19 #ifdef __cplusplus
  20 /* SwigValueWrapper is described in swig.swg */
  21 template<typename T> class SwigValueWrapper {
  22   struct SwigMovePointer {
  23     T *ptr;
  24     SwigMovePointer(T *p) : ptr(p) { }
  25     ~SwigMovePointer() { delete ptr; }
  26     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  27   } pointer;
  28   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  29   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  30 public:
  31   SwigValueWrapper() : pointer(0) { }
  32   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  33   operator T&() const { return *pointer.ptr; }
  34   T *operator&() { return pointer.ptr; }
  35 };
  36
  37 template <typename T> T SwigValueInit() {
  38   return T();
  39 }
  40 #endif
  41
  42 /* -----------------------------------------------------------------------------
  43  *  This section contains generic SWIG labels for method/variable
  44  *  declarations/attributes, and other compiler dependent labels.
  45  * ----------------------------------------------------------------------------- */
  46
  47 /* template workaround for compilers that cannot correctly implement the C++ standard */
  48 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  49 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  50 #  define SWIGTEMPLATEDISAMBIGUATOR template
  51 # elif defined(__HP_aCC)
  52 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  53 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  54 #  define SWIGTEMPLATEDISAMBIGUATOR template
  55 # else
  56 #  define SWIGTEMPLATEDISAMBIGUATOR
  57 # endif
  58 #endif
  59
  60 /* inline attribute */
  61 #ifndef SWIGINLINE
  62 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  63 #   define SWIGINLINE inline
  64 # else
  65 #   define SWIGINLINE
  66 # endif
  67 #endif
  68
  69 /* attribute recognised by some compilers to avoid 'unused' warnings */
  70 #ifndef SWIGUNUSED
  71 # if defined(__GNUC__)
  72 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  73 #     define SWIGUNUSED __attribute__ ((__unused__))
  74 #   else
  75 #     define SWIGUNUSED
  76 #   endif
  77 # elif defined(__ICC)
  78 #   define SWIGUNUSED __attribute__ ((__unused__))
  79 # else
  80 #   define SWIGUNUSED
  81 # endif
  82 #endif
  83
  84 #ifndef SWIG_MSC_UNSUPPRESS_4505
  85 # if defined(_MSC_VER)
  86 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  87 # endif
  88 #endif
  89
  90 #ifndef SWIGUNUSEDPARM
  91 # ifdef __cplusplus
  92 #   define SWIGUNUSEDPARM(p)
  93 # else
  94 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  95 # endif
  96 #endif
  97
  98 /* internal SWIG method */
  99 #ifndef SWIGINTERN
 100 # define SWIGINTERN static SWIGUNUSED
 101 #endif
 102
 103 /* internal inline SWIG method */
 104 #ifndef SWIGINTERNINLINE
 105 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 106 #endif
 107
 108 /* exporting methods */
 109 #if defined(__GNUC__)
 110 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 111 #    ifndef GCC_HASCLASSVISIBILITY
 112 #      define GCC_HASCLASSVISIBILITY
 113 #    endif
 114 #  endif
 115 #endif
 116
 117 #ifndef SWIGEXPORT
 118 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 119 #   if defined(STATIC_LINKED)
 120 #     define SWIGEXPORT
 121 #   else
 122 #     define SWIGEXPORT __declspec(dllexport)
 123 #   endif
 124 # else
 125 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 126 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 127 #   else
 128 #     define SWIGEXPORT
 129 #   endif
 130 # endif
 131 #endif
 132
 133 /* calling conventions for Windows */
 134 #ifndef SWIGSTDCALL
 135 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 136 #   define SWIGSTDCALL __stdcall
 137 # else
 138 #   define SWIGSTDCALL
 139 # endif
 140 #endif
 141
 142 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 143 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 144 # define _CRT_SECURE_NO_DEPRECATE
 145 #endif
 146
 147 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 148 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 149 # define _SCL_SECURE_NO_DEPRECATE
 150 #endif
 151
 152 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 153 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 154 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 155 #endif
 156
 157 /* Intel's compiler complains if a variable which was never initialised is
 158  * cast to void, which is a common idiom which we use to indicate that we
 159  * are aware a variable isn't used.  So we just silence that warning.
 160  * See: https://github.com/swig/swig/issues/192 for more discussion.
 161  */
 162 #ifdef __INTEL_COMPILER
 163 # pragma warning disable 592
 164 #endif
 165
 166
 167 #include <stdlib.h>
 168 #include <string.h>
 169 #include <stdio.h>
 170
 171
 172 /* Support for throwing C# exceptions from C/C++. There are two types:
 173  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 174 typedef enum {
 175   SWIG_CSharpApplicationException,
 176   SWIG_CSharpArithmeticException,
 177   SWIG_CSharpDivideByZeroException,
 178   SWIG_CSharpIndexOutOfRangeException,
 179   SWIG_CSharpInvalidCastException,
 180   SWIG_CSharpInvalidOperationException,
 181   SWIG_CSharpIOException,
 182   SWIG_CSharpNullReferenceException,
 183   SWIG_CSharpOutOfMemoryException,
 184   SWIG_CSharpOverflowException,
 185   SWIG_CSharpSystemException
 186 } SWIG_CSharpExceptionCodes;
 187
 188 typedef enum {
 189   SWIG_CSharpArgumentException,
 190   SWIG_CSharpArgumentNullException,
 191   SWIG_CSharpArgumentOutOfRangeException
 192 } SWIG_CSharpExceptionArgumentCodes;
 193
 194 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 195 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 196
 197 typedef struct {
 198   SWIG_CSharpExceptionCodes code;
 199   SWIG_CSharpExceptionCallback_t callback;
 200 } SWIG_CSharpException_t;
 201
 202 typedef struct {
 203   SWIG_CSharpExceptionArgumentCodes code;
 204   SWIG_CSharpExceptionArgumentCallback_t callback;
 205 } SWIG_CSharpExceptionArgument_t;
 206
 207 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 <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425 #include <dali/devel-api/events/key-event-devel.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 #include <dali/devel-api/adaptor-framework/imf-manager.h>
 470
 471
 472 // add here SWIG version check
 473
 474 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 475 // disable Swig-dependent warnings
 476
 477 // 'identifier1' has C-linkage specified,
 478 // but returns UDT 'identifier2' which is incompatible with C
 479 #pragma warning(disable: 4190)
 480
 481 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 482 #pragma warning(disable: 4800)
 483
 484 // debug info too long etc etc
 485 #pragma warning(disable: 4786)
 486 #endif
 487
 488
 489 #include <stdexcept>
 490
 491
 492 #include <string>
 493
 494
 495 #include <vector>
 496 #include <algorithm>
 497 #include <stdexcept>
 498
 499
 500 #include <map>
 501 #include <algorithm>
 502 #include <stdexcept>
 503
 504
 505 #include <utility>
 506
 507
 508 typedef float floatp;
 509
 510 SWIGINTERN floatp *new_floatp(){
 511   return new float();
 512 }
 513 SWIGINTERN void delete_floatp(floatp *self){
 514   if (self) delete self;
 515 }
 516 SWIGINTERN void floatp_assign(floatp *self,float value){
 517   *self = value;
 518 }
 519 SWIGINTERN float floatp_value(floatp *self){
 520   return *self;
 521 }
 522 SWIGINTERN float *floatp_cast(floatp *self){
 523   return self;
 524 }
 525 SWIGINTERN floatp *floatp_frompointer(float *t){
 526   return (floatp *) t;
 527 }
 528
 529 typedef int intp;
 530
 531 SWIGINTERN intp *new_intp(){
 532   return new int();
 533 }
 534 SWIGINTERN void delete_intp(intp *self){
 535   if (self) delete self;
 536 }
 537 SWIGINTERN void intp_assign(intp *self,int value){
 538   *self = value;
 539 }
 540 SWIGINTERN int intp_value(intp *self){
 541   return *self;
 542 }
 543 SWIGINTERN int *intp_cast(intp *self){
 544   return self;
 545 }
 546 SWIGINTERN intp *intp_frompointer(int *t){
 547   return (intp *) t;
 548 }
 549
 550 typedef double doublep;
 551
 552 SWIGINTERN doublep *new_doublep(){
 553   return new double();
 554 }
 555 SWIGINTERN void delete_doublep(doublep *self){
 556   if (self) delete self;
 557 }
 558 SWIGINTERN void doublep_assign(doublep *self,double value){
 559   *self = value;
 560 }
 561 SWIGINTERN double doublep_value(doublep *self){
 562   return *self;
 563 }
 564 SWIGINTERN double *doublep_cast(doublep *self){
 565   return self;
 566 }
 567 SWIGINTERN doublep *doublep_frompointer(double *t){
 568   return (doublep *) t;
 569 }
 570
 571 typedef unsigned int uintp;
 572
 573 SWIGINTERN uintp *new_uintp(){
 574   return new unsigned int();
 575 }
 576 SWIGINTERN void delete_uintp(uintp *self){
 577   if (self) delete self;
 578 }
 579 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 580   *self = value;
 581 }
 582 SWIGINTERN unsigned int uintp_value(uintp *self){
 583   return *self;
 584 }
 585 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 586   return self;
 587 }
 588 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 589   return (uintp *) t;
 590 }
 591
 592 typedef unsigned short ushortp;
 593
 594 SWIGINTERN ushortp *new_ushortp(){
 595   return new unsigned short();
 596 }
 597 SWIGINTERN void delete_ushortp(ushortp *self){
 598   if (self) delete self;
 599 }
 600 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 601   *self = value;
 602 }
 603 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 604   return *self;
 605 }
 606 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 607   return self;
 608 }
 609 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 610   return (ushortp *) t;
 611 }
 612
 613 unsigned int int_to_uint(int x) {
 614    return (unsigned int) x;
 615 }
 616
 617
 618 using namespace Dali;
 619 using namespace Dali::Toolkit;
 620
 621 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self){
 622
 623      // C++ code. DALi uses Handle <-> Body design pattern.
 624      // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 625      // Handles in DALi can be converted into a boolean type
 626      // to check if the handle has a valid body attached to it.
 627      // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 628      if( *self )
 629      {
 630        return true;
 631      }
 632      else
 633      {
 634        return false;
 635      }
 636     }
 637 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs){
 638
 639      // C++ code. Check if two handles reference the same implemtion
 640      if( *self == rhs)
 641      {
 642        return true;
 643      }
 644      else
 645      {
 646        return false;
 647      }
 648     }
 649 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 650      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 651    }
 652 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){
 653      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 654    }
 655 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 656         std::vector< Dali::TouchPoint >* pv = 0;
 657         if (capacity >= 0) {
 658           pv = new std::vector< Dali::TouchPoint >();
 659           pv->reserve(capacity);
 660        } else {
 661           throw std::out_of_range("capacity");
 662        }
 663        return pv;
 664       }
 665 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 666         if (index>=0 && index<(int)self->size())
 667           return (*self)[index];
 668         else
 669           throw std::out_of_range("index");
 670       }
 671 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 672         if (index>=0 && index<(int)self->size())
 673           return (*self)[index];
 674         else
 675           throw std::out_of_range("index");
 676       }
 677 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 678         if (index>=0 && index<(int)self->size())
 679           (*self)[index] = val;
 680         else
 681           throw std::out_of_range("index");
 682       }
 683 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 684         self->insert(self->end(), values.begin(), values.end());
 685       }
 686 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 687         if (index < 0)
 688           throw std::out_of_range("index");
 689         if (count < 0)
 690           throw std::out_of_range("count");
 691         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 692           throw std::invalid_argument("invalid range");
 693         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 694       }
 695 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 696         if (index>=0 && index<(int)self->size()+1)
 697           self->insert(self->begin()+index, x);
 698         else
 699           throw std::out_of_range("index");
 700       }
 701 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 702         if (index>=0 && index<(int)self->size()+1)
 703           self->insert(self->begin()+index, values.begin(), values.end());
 704         else
 705           throw std::out_of_range("index");
 706       }
 707 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 708         if (index>=0 && index<(int)self->size())
 709           self->erase(self->begin() + index);
 710         else
 711           throw std::out_of_range("index");
 712       }
 713 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 714         if (index < 0)
 715           throw std::out_of_range("index");
 716         if (count < 0)
 717           throw std::out_of_range("count");
 718         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 719           throw std::invalid_argument("invalid range");
 720         self->erase(self->begin()+index, self->begin()+index+count);
 721       }
 722 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 723         if (count < 0)
 724           throw std::out_of_range("count");
 725         return new std::vector< Dali::TouchPoint >(count, value);
 726       }
 727 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 728         std::reverse(self->begin(), self->end());
 729       }
 730 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 731         if (index < 0)
 732           throw std::out_of_range("index");
 733         if (count < 0)
 734           throw std::out_of_range("count");
 735         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 736           throw std::invalid_argument("invalid range");
 737         std::reverse(self->begin()+index, self->begin()+index+count);
 738       }
 739 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 740         if (index < 0)
 741           throw std::out_of_range("index");
 742         if (index+values.size() > self->size())
 743           throw std::out_of_range("index");
 744         std::copy(values.begin(), values.end(), self->begin()+index);
 745       }
 746 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 747          return self->Empty();
 748       }
 749 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 750         return self->GetConnectionCount();
 751       }
 752 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 753           self->Connect( func );
 754       }
 755 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 756           self->Disconnect( func );
 757       }
 758 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 759           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 760 /*@SWIG@*/ self->Emit( arg );
 761       }
 762 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 763          return self->Empty();
 764       }
 765 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 766         return self->GetConnectionCount();
 767       }
 768 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 769           self->Connect( func );
 770       }
 771 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 772           self->Disconnect( func );
 773       }
 774 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 775           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 776 /*@SWIG@*/ self->Emit( arg );
 777       }
 778 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 779          return self->Empty();
 780       }
 781 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){
 782         return self->GetConnectionCount();
 783       }
 784 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 *)){
 785           self->Connect( func );
 786       }
 787 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 *)){
 788           self->Disconnect( func );
 789       }
 790 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){
 791           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 792 /*@SWIG@*/ self->Emit( arg );
 793       }
 794 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 795          return self->Empty();
 796       }
 797 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 798         return self->GetConnectionCount();
 799       }
 800 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 801           self->Connect( func );
 802       }
 803 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 804           self->Disconnect( func );
 805       }
 806 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 807           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 808 /*@SWIG@*/ self->Emit( arg );
 809       }
 810 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 811          return self->Empty();
 812       }
 813 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 814         return self->GetConnectionCount();
 815       }
 816 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 817           self->Connect( func );
 818       }
 819 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 820           self->Disconnect( func );
 821       }
 822 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 823           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 824 /*@SWIG@*/ self->Emit( arg );
 825       }
 826 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){
 827          return self->Empty();
 828       }
 829 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){
 830         return self->GetConnectionCount();
 831       }
 832 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 &)){
 833         self->Connect( func );
 834       }
 835 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 &)){
 836         self->Disconnect( func );
 837       }
 838 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){
 839         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 840 /*@SWIG@*/ self->Emit( arg1, arg2 );
 841       }
 842 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){
 843          return self->Empty();
 844       }
 845 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){
 846         return self->GetConnectionCount();
 847       }
 848 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 &)){
 849         self->Connect( func );
 850       }
 851 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 &)){
 852         self->Disconnect( func );
 853       }
 854 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){
 855         return self->Emit( arg1, arg2 );
 856       }
 857 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){
 858          return self->Empty();
 859       }
 860 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){
 861         return self->GetConnectionCount();
 862       }
 863 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 &)){
 864         self->Connect( func );
 865       }
 866 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 &)){
 867         self->Disconnect( func );
 868       }
 869 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){
 870         return self->Emit( arg1, arg2 );
 871       }
 872 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){
 873          return self->Empty();
 874       }
 875 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){
 876         return self->GetConnectionCount();
 877       }
 878 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 &)){
 879         self->Connect( func );
 880       }
 881 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 &)){
 882         self->Disconnect( func );
 883       }
 884 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){
 885         return self->Emit( arg1, arg2 );
 886       }
 887 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 888          return self->Empty();
 889       }
 890 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 891         return self->GetConnectionCount();
 892       }
 893 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 894           self->Connect( func );
 895       }
 896 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 897           self->Disconnect( func );
 898       }
 899 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 900           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 901 /*@SWIG@*/ self->Emit( arg );
 902       }
 903 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 904          return self->Empty();
 905       }
 906 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){
 907         return self->GetConnectionCount();
 908       }
 909 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 &)){
 910           self->Connect( func );
 911       }
 912 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 &)){
 913           self->Disconnect( func );
 914       }
 915 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){
 916           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 917 /*@SWIG@*/ self->Emit( arg );
 918       }
 919 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 920          return self->Empty();
 921       }
 922 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){
 923         return self->GetConnectionCount();
 924       }
 925 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 &)){
 926           self->Connect( func );
 927       }
 928 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 &)){
 929           self->Disconnect( func );
 930       }
 931 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){
 932           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 933 /*@SWIG@*/ self->Emit( arg );
 934       }
 935 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 936          return self->Empty();
 937       }
 938 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){
 939         return self->GetConnectionCount();
 940       }
 941 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 &)){
 942           self->Connect( func );
 943       }
 944 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 &)){
 945           self->Disconnect( func );
 946       }
 947 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){
 948           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 949 /*@SWIG@*/ self->Emit( arg );
 950       }
 951 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){
 952          return self->Empty();
 953       }
 954 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){
 955         return self->GetConnectionCount();
 956       }
 957 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 &)){
 958         self->Connect( func );
 959       }
 960 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 &)){
 961         self->Disconnect( func );
 962       }
 963 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){
 964         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 965 /*@SWIG@*/ self->Emit( arg1, arg2 );
 966       }
 967 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){
 968          return self->Empty();
 969       }
 970 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){
 971         return self->GetConnectionCount();
 972       }
 973 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 &)){
 974         self->Connect( func );
 975       }
 976 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 &)){
 977         self->Disconnect( func );
 978       }
 979 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){
 980         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 981 /*@SWIG@*/ self->Emit( arg1, arg2 );
 982       }
 983 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){
 984          return self->Empty();
 985       }
 986 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){
 987         return self->GetConnectionCount();
 988       }
 989 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 &)){
 990         self->Connect( func );
 991       }
 992 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 &)){
 993         self->Disconnect( func );
 994       }
 995 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){
 996         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 997 /*@SWIG@*/ self->Emit( arg1, arg2 );
 998       }
 999 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Animation &) > const *self){
1000          return self->Empty();
1001       }
1002 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Animation &) > const *self){
1003         return self->GetConnectionCount();
1004       }
1005 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1006           self->Connect( func );
1007       }
1008 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Animation &) > *self,void (*func)(Dali::Animation &)){
1009           self->Disconnect( func );
1010       }
1011 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Animation &) > *self,Dali::Animation &arg){
1012           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1013 /*@SWIG@*/ self->Emit( arg );
1014       }
1015 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1016          return self->Empty();
1017       }
1018 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1019         return self->GetConnectionCount();
1020       }
1021 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1022           self->Connect( func );
1023       }
1024 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1025           self->Disconnect( func );
1026       }
1027 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1028           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1029 /*@SWIG@*/ self->Emit( arg );
1030       }
1031
1032   // keep argcs and argv so they're always available to DALi
1033   int argC = 1;
1034   char **argV = NULL;
1035
1036 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Application &) > const *self){
1037          return self->Empty();
1038       }
1039 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Application &) > const *self){
1040         return self->GetConnectionCount();
1041       }
1042 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1043           self->Connect( func );
1044       }
1045 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::Application &) > *self,void (*func)(Dali::Application &)){
1046           self->Disconnect( func );
1047       }
1048 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(Dali::Signal< void (Dali::Application &) > *self,Dali::Application &arg){
1049           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1050 /*@SWIG@*/ self->Emit( arg );
1051       }
1052 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::Application &,void *) > const *self){
1053          return self->Empty();
1054       }
1055 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){
1056         return self->GetConnectionCount();
1057       }
1058 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 *)){
1059         self->Connect( func );
1060       }
1061 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 *)){
1062         self->Disconnect( func );
1063       }
1064 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){
1065         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1066 /*@SWIG@*/ self->Emit( arg1, arg2 );
1067       }
1068 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1069          return self->Empty();
1070       }
1071 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1072         return self->GetConnectionCount();
1073       }
1074 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1075           self->Connect( func );
1076       }
1077 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1078           self->Disconnect( func );
1079       }
1080 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1081           return self->Emit();
1082       }
1083 SWIGINTERN bool Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty(Dali::Signal< void (bool) > const *self){
1084          return self->Empty();
1085       }
1086 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (bool) > const *self){
1087         return self->GetConnectionCount();
1088       }
1089 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1090           self->Connect( func );
1091       }
1092 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(Dali::Signal< void (bool) > *self,void (*func)(bool)){
1093           self->Disconnect( func );
1094       }
1095 SWIGINTERN void Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(Dali::Signal< void (bool) > *self,bool arg){
1096           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1097 /*@SWIG@*/ self->Emit( arg );
1098       }
1099 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1100         std::vector< unsigned int >* pv = 0;
1101         if (capacity >= 0) {
1102           pv = new std::vector< unsigned int >();
1103           pv->reserve(capacity);
1104        } else {
1105           throw std::out_of_range("capacity");
1106        }
1107        return pv;
1108       }
1109 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1110         if (index>=0 && index<(int)self->size())
1111           return (*self)[index];
1112         else
1113           throw std::out_of_range("index");
1114       }
1115 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1116         if (index>=0 && index<(int)self->size())
1117           return (*self)[index];
1118         else
1119           throw std::out_of_range("index");
1120       }
1121 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1122         if (index>=0 && index<(int)self->size())
1123           (*self)[index] = val;
1124         else
1125           throw std::out_of_range("index");
1126       }
1127 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1128         self->insert(self->end(), values.begin(), values.end());
1129       }
1130 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1131         if (index < 0)
1132           throw std::out_of_range("index");
1133         if (count < 0)
1134           throw std::out_of_range("count");
1135         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1136           throw std::invalid_argument("invalid range");
1137         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1138       }
1139 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1140         if (index>=0 && index<(int)self->size()+1)
1141           self->insert(self->begin()+index, x);
1142         else
1143           throw std::out_of_range("index");
1144       }
1145 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1146         if (index>=0 && index<(int)self->size()+1)
1147           self->insert(self->begin()+index, values.begin(), values.end());
1148         else
1149           throw std::out_of_range("index");
1150       }
1151 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1152         if (index>=0 && index<(int)self->size())
1153           self->erase(self->begin() + index);
1154         else
1155           throw std::out_of_range("index");
1156       }
1157 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1158         if (index < 0)
1159           throw std::out_of_range("index");
1160         if (count < 0)
1161           throw std::out_of_range("count");
1162         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1163           throw std::invalid_argument("invalid range");
1164         self->erase(self->begin()+index, self->begin()+index+count);
1165       }
1166 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1167         if (count < 0)
1168           throw std::out_of_range("count");
1169         return new std::vector< unsigned int >(count, value);
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1172         std::reverse(self->begin(), self->end());
1173       }
1174 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1175         if (index < 0)
1176           throw std::out_of_range("index");
1177         if (count < 0)
1178           throw std::out_of_range("count");
1179         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1180           throw std::invalid_argument("invalid range");
1181         std::reverse(self->begin()+index, self->begin()+index+count);
1182       }
1183 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1184         if (index < 0)
1185           throw std::out_of_range("index");
1186         if (index+values.size() > self->size())
1187           throw std::out_of_range("index");
1188         std::copy(values.begin(), values.end(), self->begin()+index);
1189       }
1190 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1191         return std::find(self->begin(), self->end(), value) != self->end();
1192       }
1193 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1194         int index = -1;
1195         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1196         if (it != self->end())
1197           index = (int)(it - self->begin());
1198         return index;
1199       }
1200 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1201         int index = -1;
1202         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1203         if (rit != self->rend())
1204           index = (int)(self->rend() - 1 - rit);
1205         return index;
1206       }
1207 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1208         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1209         if (it != self->end()) {
1210           self->erase(it);
1211           return true;
1212         }
1213         return false;
1214       }
1215 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){
1216         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1217         if (capacity >= 0) {
1218           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1219           pv->reserve(capacity);
1220        } else {
1221           throw std::out_of_range("capacity");
1222        }
1223        return pv;
1224       }
1225 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){
1226         if (index>=0 && index<(int)self->size())
1227           return (*self)[index];
1228         else
1229           throw std::out_of_range("index");
1230       }
1231 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){
1232         if (index>=0 && index<(int)self->size())
1233           return (*self)[index];
1234         else
1235           throw std::out_of_range("index");
1236       }
1237 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){
1238         if (index>=0 && index<(int)self->size())
1239           (*self)[index] = val;
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__AddRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,std::vector< std::pair< unsigned int,Dali::Actor > > const &values){
1244         self->insert(self->end(), values.begin(), values.end());
1245       }
1246 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){
1247         if (index < 0)
1248           throw std::out_of_range("index");
1249         if (count < 0)
1250           throw std::out_of_range("count");
1251         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1252           throw std::invalid_argument("invalid range");
1253         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1254       }
1255 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){
1256         if (index>=0 && index<(int)self->size()+1)
1257           self->insert(self->begin()+index, x);
1258         else
1259           throw std::out_of_range("index");
1260       }
1261 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){
1262         if (index>=0 && index<(int)self->size()+1)
1263           self->insert(self->begin()+index, values.begin(), values.end());
1264         else
1265           throw std::out_of_range("index");
1266       }
1267 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){
1268         if (index>=0 && index<(int)self->size())
1269           self->erase(self->begin() + index);
1270         else
1271           throw std::out_of_range("index");
1272       }
1273 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){
1274         if (index < 0)
1275           throw std::out_of_range("index");
1276         if (count < 0)
1277           throw std::out_of_range("count");
1278         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1279           throw std::invalid_argument("invalid range");
1280         self->erase(self->begin()+index, self->begin()+index+count);
1281       }
1282 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){
1283         if (count < 0)
1284           throw std::out_of_range("count");
1285         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1286       }
1287 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){
1288         std::reverse(self->begin(), self->end());
1289       }
1290 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){
1291         if (index < 0)
1292           throw std::out_of_range("index");
1293         if (count < 0)
1294           throw std::out_of_range("count");
1295         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1296           throw std::invalid_argument("invalid range");
1297         std::reverse(self->begin()+index, self->begin()+index+count);
1298       }
1299 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){
1300         if (index < 0)
1301           throw std::out_of_range("index");
1302         if (index+values.size() > self->size())
1303           throw std::out_of_range("index");
1304         std::copy(values.begin(), values.end(), self->begin()+index);
1305       }
1306 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1307         std::vector< Dali::Actor >* pv = 0;
1308         if (capacity >= 0) {
1309           pv = new std::vector< Dali::Actor >();
1310           pv->reserve(capacity);
1311        } else {
1312           throw std::out_of_range("capacity");
1313        }
1314        return pv;
1315       }
1316 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1317         if (index>=0 && index<(int)self->size())
1318           return (*self)[index];
1319         else
1320           throw std::out_of_range("index");
1321       }
1322 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1323         if (index>=0 && index<(int)self->size())
1324           return (*self)[index];
1325         else
1326           throw std::out_of_range("index");
1327       }
1328 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1329         if (index>=0 && index<(int)self->size())
1330           (*self)[index] = val;
1331         else
1332           throw std::out_of_range("index");
1333       }
1334 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1335         self->insert(self->end(), values.begin(), values.end());
1336       }
1337 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1338         if (index < 0)
1339           throw std::out_of_range("index");
1340         if (count < 0)
1341           throw std::out_of_range("count");
1342         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1343           throw std::invalid_argument("invalid range");
1344         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1345       }
1346 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1347         if (index>=0 && index<(int)self->size()+1)
1348           self->insert(self->begin()+index, x);
1349         else
1350           throw std::out_of_range("index");
1351       }
1352 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1353         if (index>=0 && index<(int)self->size()+1)
1354           self->insert(self->begin()+index, values.begin(), values.end());
1355         else
1356           throw std::out_of_range("index");
1357       }
1358 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1359         if (index>=0 && index<(int)self->size())
1360           self->erase(self->begin() + index);
1361         else
1362           throw std::out_of_range("index");
1363       }
1364 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1365         if (index < 0)
1366           throw std::out_of_range("index");
1367         if (count < 0)
1368           throw std::out_of_range("count");
1369         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1370           throw std::invalid_argument("invalid range");
1371         self->erase(self->begin()+index, self->begin()+index+count);
1372       }
1373 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1374         if (count < 0)
1375           throw std::out_of_range("count");
1376         return new std::vector< Dali::Actor >(count, value);
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1379         std::reverse(self->begin(), self->end());
1380       }
1381 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1382         if (index < 0)
1383           throw std::out_of_range("index");
1384         if (count < 0)
1385           throw std::out_of_range("count");
1386         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1387           throw std::invalid_argument("invalid range");
1388         std::reverse(self->begin()+index, self->begin()+index+count);
1389       }
1390 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1391         if (index < 0)
1392           throw std::out_of_range("index");
1393         if (index+values.size() > self->size())
1394           throw std::out_of_range("index");
1395         std::copy(values.begin(), values.end(), self->begin()+index);
1396       }
1397 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1398          return self->Empty();
1399       }
1400 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1401         return self->GetConnectionCount();
1402       }
1403 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 &)){
1404           self->Connect( func );
1405       }
1406 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 &)){
1407           self->Disconnect( func );
1408       }
1409 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){
1410           return self->Emit( arg );
1411       }
1412 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){
1413          return self->Empty();
1414       }
1415 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){
1416         return self->GetConnectionCount();
1417       }
1418 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)){
1419         self->Connect( func );
1420       }
1421 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)){
1422         self->Disconnect( func );
1423       }
1424 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){
1425         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1426 /*@SWIG@*/ self->Emit( arg1, arg2 );
1427       }
1428 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1429          return self->Empty();
1430       }
1431 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){
1432         return self->GetConnectionCount();
1433       }
1434 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)){
1435         self->Connect( func );
1436       }
1437 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)){
1438         self->Disconnect( func );
1439       }
1440 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){
1441         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1442 /*@SWIG@*/ self->Emit( arg1, arg2 );
1443       }
1444 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1445          return self->Empty();
1446       }
1447 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1448         return self->GetConnectionCount();
1449       }
1450 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)){
1451         self->Connect( func );
1452       }
1453 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)){
1454         self->Disconnect( func );
1455       }
1456 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){
1457         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1458 /*@SWIG@*/ self->Emit( arg1, arg2 );
1459       }
1460 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1461          return self->Empty();
1462       }
1463 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){
1464         return self->GetConnectionCount();
1465       }
1466 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)){
1467         self->Connect( func );
1468       }
1469 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)){
1470         self->Disconnect( func );
1471       }
1472 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){
1473         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1474 /*@SWIG@*/ self->Emit( arg1, arg2 );
1475       }
1476 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1477          return self->Empty();
1478       }
1479 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1480         return self->GetConnectionCount();
1481       }
1482 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)){
1483           self->Connect( func );
1484       }
1485 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)){
1486           self->Disconnect( func );
1487       }
1488 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1489           return self->Emit( arg );
1490       }
1491 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1492          return self->Empty();
1493       }
1494 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1495         return self->GetConnectionCount();
1496       }
1497 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)){
1498           self->Connect( func );
1499       }
1500 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)){
1501           self->Disconnect( func );
1502       }
1503 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1504           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1505 /*@SWIG@*/ self->Emit( arg );
1506       }
1507 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){
1508          return self->Empty();
1509       }
1510 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){
1511         return self->GetConnectionCount();
1512       }
1513 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)){
1514           return self->Connect( func );
1515       }
1516 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)){
1517           self->Disconnect( func );
1518       }
1519 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){
1520           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1521 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1522       }
1523 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1524          return self->Empty();
1525       }
1526 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1527         return self->GetConnectionCount();
1528       }
1529 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)){
1530           self->Connect( func );
1531       }
1532 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)){
1533           self->Disconnect( func );
1534       }
1535 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1536           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1537 /*@SWIG@*/ self->Emit( arg );
1538       }
1539 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){
1540          return self->Empty();
1541       }
1542 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){
1543         return self->GetConnectionCount();
1544       }
1545 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)){
1546           return self->Connect( func );
1547       }
1548 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)){
1549           self->Disconnect( func );
1550       }
1551 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){
1552           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1553 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1554       }
1555 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){
1556          return self->Empty();
1557       }
1558 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){
1559         return self->GetConnectionCount();
1560       }
1561 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 &)){
1562           self->Connect( func );
1563       }
1564 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 &)){
1565           self->Disconnect( func );
1566       }
1567 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){
1568           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1569 /*@SWIG@*/ self->Emit( arg );
1570       }
1571 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1572          return self->Empty();
1573       }
1574 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){
1575         return self->GetConnectionCount();
1576       }
1577 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 &)){
1578           self->Connect( func );
1579       }
1580 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 &)){
1581           self->Disconnect( func );
1582       }
1583 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){
1584           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1585 /*@SWIG@*/ self->Emit( arg );
1586       }
1587 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1588          return self->Empty();
1589       }
1590 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextEditor) > const *self){
1591         return self->GetConnectionCount();
1592       }
1593 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)){
1594           self->Connect( func );
1595       }
1596 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)){
1597           self->Disconnect( func );
1598       }
1599 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextEditor) > *self,Dali::Toolkit::TextEditor arg){
1600           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1601 /*@SWIG@*/ self->Emit( arg );
1602       }
1603 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1604          return self->Empty();
1605       }
1606 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::TextField) > const *self){
1607         return self->GetConnectionCount();
1608       }
1609 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)){
1610           self->Connect( func );
1611       }
1612 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)){
1613           self->Disconnect( func );
1614       }
1615 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::TextField) > *self,Dali::Toolkit::TextField arg){
1616           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1617 /*@SWIG@*/ self->Emit( arg );
1618       }
1619 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){
1620          return self->Empty();
1621       }
1622 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){
1623         return self->GetConnectionCount();
1624       }
1625 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 &)){
1626         self->Connect( func );
1627       }
1628 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 &)){
1629         self->Disconnect( func );
1630       }
1631 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){
1632         return self->Emit( arg1, arg2 );
1633       }
1634 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1635          return self->Empty();
1636       }
1637 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1638         return self->GetConnectionCount();
1639       }
1640 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)){
1641           self->Connect( func );
1642       }
1643 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)){
1644           self->Disconnect( func );
1645       }
1646 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1647           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1648 /*@SWIG@*/ self->Emit( arg );
1649       }
1650 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1651          return self->Empty();
1652       }
1653 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1654         return self->GetConnectionCount();
1655       }
1656 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 &)){
1657           self->Connect( func );
1658       }
1659 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 &)){
1660           self->Disconnect( func );
1661       }
1662 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){
1663           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1664 /*@SWIG@*/ self->Emit( arg );
1665       }
1666 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1667          return self->Empty();
1668       }
1669 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){
1670         return self->GetConnectionCount();
1671       }
1672 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)){
1673         self->Connect( func );
1674       }
1675 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)){
1676         self->Disconnect( func );
1677       }
1678 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){
1679         return self->Emit( arg1, arg2 );
1680       }
1681 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1682          return self->Empty();
1683       }
1684 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){
1685         return self->GetConnectionCount();
1686       }
1687 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)){
1688         self->Connect( func );
1689       }
1690 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)){
1691         self->Disconnect( func );
1692       }
1693 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){
1694         return self->Emit( arg1, arg2 );
1695       }
1696
1697
1698 /* ---------------------------------------------------
1699  * C++ director class methods
1700  * --------------------------------------------------- */
1701
1702 #include "dali_wrap.h"
1703
1704 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1705   swig_init_callbacks();
1706 }
1707
1708 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1709
1710 }
1711
1712
1713 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1714   int jdepth  ;
1715
1716   if (!swig_callbackOnStageConnection) {
1717     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1718     return;
1719   } else {
1720     jdepth = depth;
1721     swig_callbackOnStageConnection(jdepth);
1722   }
1723 }
1724
1725 void SwigDirector_ViewImpl::OnStageDisconnection() {
1726   if (!swig_callbackOnStageDisconnection) {
1727     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1728     return;
1729   } else {
1730     swig_callbackOnStageDisconnection();
1731   }
1732 }
1733
1734 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1735   void * jchild = 0 ;
1736
1737   if (!swig_callbackOnChildAdd) {
1738     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1739     return;
1740   } else {
1741     jchild = (Dali::Actor *) &child;
1742     swig_callbackOnChildAdd(jchild);
1743   }
1744 }
1745
1746 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1747   void * jchild = 0 ;
1748
1749   if (!swig_callbackOnChildRemove) {
1750     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1751     return;
1752   } else {
1753     jchild = (Dali::Actor *) &child;
1754     swig_callbackOnChildRemove(jchild);
1755   }
1756 }
1757
1758 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1759   int jindex  ;
1760   void * jpropertyValue  ;
1761
1762   if (!swig_callbackOnPropertySet) {
1763     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1764     return;
1765   } else {
1766     jindex = index;
1767     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1768     swig_callbackOnPropertySet(jindex, jpropertyValue);
1769   }
1770 }
1771
1772 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1773   void * jtargetSize = 0 ;
1774
1775   if (!swig_callbackOnSizeSet) {
1776     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1777     return;
1778   } else {
1779     jtargetSize = (Dali::Vector3 *) &targetSize;
1780     swig_callbackOnSizeSet(jtargetSize);
1781   }
1782 }
1783
1784 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1785   void * janimation = 0 ;
1786   void * jtargetSize = 0 ;
1787
1788   if (!swig_callbackOnSizeAnimation) {
1789     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1790     return;
1791   } else {
1792     janimation = (Dali::Animation *) &animation;
1793     jtargetSize = (Dali::Vector3 *) &targetSize;
1794     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1795   }
1796 }
1797
1798 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1799   bool c_result = SwigValueInit< bool >() ;
1800   unsigned int jresult = 0 ;
1801   void * jarg0 = 0 ;
1802
1803   if (!swig_callbackOnTouchEvent) {
1804     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1805   } else {
1806     jarg0 = (Dali::TouchEvent *) &event;
1807     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1808     c_result = jresult ? true : false;
1809   }
1810   return c_result;
1811 }
1812
1813 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1814   bool c_result = SwigValueInit< bool >() ;
1815   unsigned int jresult = 0 ;
1816   void * jarg0 = 0 ;
1817
1818   if (!swig_callbackOnHoverEvent) {
1819     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1820   } else {
1821     jarg0 = (Dali::HoverEvent *) &event;
1822     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1823     c_result = jresult ? true : false;
1824   }
1825   return c_result;
1826 }
1827
1828 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1829   bool c_result = SwigValueInit< bool >() ;
1830   unsigned int jresult = 0 ;
1831   void * jarg0 = 0 ;
1832
1833   if (!swig_callbackOnKeyEvent) {
1834     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1835   } else {
1836     jarg0 = (Dali::KeyEvent *) &event;
1837     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1838     c_result = jresult ? true : false;
1839   }
1840   return c_result;
1841 }
1842
1843 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1844   bool c_result = SwigValueInit< bool >() ;
1845   unsigned int jresult = 0 ;
1846   void * jarg0 = 0 ;
1847
1848   if (!swig_callbackOnWheelEvent) {
1849     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1850   } else {
1851     jarg0 = (Dali::WheelEvent *) &event;
1852     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1853     c_result = jresult ? true : false;
1854   }
1855   return c_result;
1856 }
1857
1858 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1859   void * jsize = 0 ;
1860   void * jcontainer = 0 ;
1861
1862   if (!swig_callbackOnRelayout) {
1863     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1864     return;
1865   } else {
1866     jsize = (Dali::Vector2 *) &size;
1867     jcontainer = (Dali::RelayoutContainer *) &container;
1868     swig_callbackOnRelayout(jsize, jcontainer);
1869   }
1870 }
1871
1872 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1873   int jpolicy  ;
1874   int jdimension  ;
1875
1876   if (!swig_callbackOnSetResizePolicy) {
1877     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1878     return;
1879   } else {
1880     jpolicy = (int)policy;
1881     jdimension = (int)dimension;
1882     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1883   }
1884 }
1885
1886 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1887   Dali::Vector3 c_result ;
1888   void * jresult = 0 ;
1889
1890   if (!swig_callbackGetNaturalSize) {
1891     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1892   } else {
1893     jresult = (void *) swig_callbackGetNaturalSize();
1894     if (!jresult) {
1895       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1896       return c_result;
1897     }
1898     c_result = *(Dali::Vector3 *)jresult;
1899   }
1900   return c_result;
1901 }
1902
1903 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
1904   float c_result = SwigValueInit< float >() ;
1905   float jresult = 0 ;
1906   void * jchild = 0 ;
1907   int jdimension  ;
1908
1909   if (!swig_callbackCalculateChildSize) {
1910     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
1911   } else {
1912     jchild = (Dali::Actor *) &child;
1913     jdimension = (int)dimension;
1914     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
1915     c_result = (float)jresult;
1916   }
1917   return c_result;
1918 }
1919
1920 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
1921   float c_result = SwigValueInit< float >() ;
1922   float jresult = 0 ;
1923   float jwidth  ;
1924
1925   if (!swig_callbackGetHeightForWidth) {
1926     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
1927   } else {
1928     jwidth = width;
1929     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
1930     c_result = (float)jresult;
1931   }
1932   return c_result;
1933 }
1934
1935 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
1936   float c_result = SwigValueInit< float >() ;
1937   float jresult = 0 ;
1938   float jheight  ;
1939
1940   if (!swig_callbackGetWidthForHeight) {
1941     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
1942   } else {
1943     jheight = height;
1944     jresult = (float) swig_callbackGetWidthForHeight(jheight);
1945     c_result = (float)jresult;
1946   }
1947   return c_result;
1948 }
1949
1950 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
1951   bool c_result = SwigValueInit< bool >() ;
1952   unsigned int jresult = 0 ;
1953   int jdimension  ;
1954
1955   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
1956     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
1957   } else {
1958     jdimension = (int)dimension;
1959     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
1960     c_result = jresult ? true : false;
1961   }
1962   return c_result;
1963 }
1964
1965 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
1966   int jdimension  ;
1967
1968   if (!swig_callbackOnCalculateRelayoutSize) {
1969     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
1970     return;
1971   } else {
1972     jdimension = (int)dimension;
1973     swig_callbackOnCalculateRelayoutSize(jdimension);
1974   }
1975 }
1976
1977 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
1978   float jsize  ;
1979   int jdimension  ;
1980
1981   if (!swig_callbackOnLayoutNegotiated) {
1982     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
1983     return;
1984   } else {
1985     jsize = size;
1986     jdimension = (int)dimension;
1987     swig_callbackOnLayoutNegotiated(jsize, jdimension);
1988   }
1989 }
1990
1991 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
1992   return Dali::CustomActorImpl::GetExtension();
1993 }
1994
1995 void SwigDirector_ViewImpl::OnInitialize() {
1996   if (!swig_callbackOnInitialize) {
1997     Dali::Toolkit::Internal::Control::OnInitialize();
1998     return;
1999   } else {
2000     swig_callbackOnInitialize();
2001   }
2002 }
2003
2004 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2005   void * jchild = 0 ;
2006
2007   if (!swig_callbackOnControlChildAdd) {
2008     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2009     return;
2010   } else {
2011     jchild = (Dali::Actor *) &child;
2012     swig_callbackOnControlChildAdd(jchild);
2013   }
2014 }
2015
2016 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2017   void * jchild = 0 ;
2018
2019   if (!swig_callbackOnControlChildRemove) {
2020     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2021     return;
2022   } else {
2023     jchild = (Dali::Actor *) &child;
2024     swig_callbackOnControlChildRemove(jchild);
2025   }
2026 }
2027
2028 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2029   void * jstyleManager  ;
2030   int jchange  ;
2031
2032   if (!swig_callbackOnStyleChange) {
2033     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2034     return;
2035   } else {
2036     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2037     jchange = (int)change;
2038     swig_callbackOnStyleChange(jstyleManager, jchange);
2039   }
2040 }
2041
2042 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2043   bool c_result = SwigValueInit< bool >() ;
2044   unsigned int jresult = 0 ;
2045
2046   if (!swig_callbackOnAccessibilityActivated) {
2047     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2048   } else {
2049     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2050     c_result = jresult ? true : false;
2051   }
2052   return c_result;
2053 }
2054
2055 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2056   bool c_result = SwigValueInit< bool >() ;
2057   unsigned int jresult = 0 ;
2058   void * jgesture  ;
2059
2060   if (!swig_callbackOnAccessibilityPan) {
2061     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2062   } else {
2063     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2064     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2065     c_result = jresult ? true : false;
2066   }
2067   return c_result;
2068 }
2069
2070 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2071   bool c_result = SwigValueInit< bool >() ;
2072   unsigned int jresult = 0 ;
2073   void * jtouchEvent = 0 ;
2074
2075   if (!swig_callbackOnAccessibilityTouch) {
2076     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2077   } else {
2078     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2079     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2080     c_result = jresult ? true : false;
2081   }
2082   return c_result;
2083 }
2084
2085 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2086   bool c_result = SwigValueInit< bool >() ;
2087   unsigned int jresult = 0 ;
2088   unsigned int jisIncrease  ;
2089
2090   if (!swig_callbackOnAccessibilityValueChange) {
2091     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2092   } else {
2093     jisIncrease = isIncrease;
2094     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2095     c_result = jresult ? true : false;
2096   }
2097   return c_result;
2098 }
2099
2100 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2101   bool c_result = SwigValueInit< bool >() ;
2102   unsigned int jresult = 0 ;
2103
2104   if (!swig_callbackOnAccessibilityZoom) {
2105     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2106   } else {
2107     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2108     c_result = jresult ? true : false;
2109   }
2110   return c_result;
2111 }
2112
2113 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2114   if (!swig_callbackOnKeyInputFocusGained) {
2115     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2116     return;
2117   } else {
2118     swig_callbackOnKeyInputFocusGained();
2119   }
2120 }
2121
2122 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2123   if (!swig_callbackOnKeyInputFocusLost) {
2124     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2125     return;
2126   } else {
2127     swig_callbackOnKeyInputFocusLost();
2128   }
2129 }
2130
2131 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2132   Dali::Actor c_result ;
2133   void * jresult = 0 ;
2134   void * jcurrentFocusedActor  ;
2135   int jdirection  ;
2136   unsigned int jloopEnabled  ;
2137
2138   if (!swig_callbackGetNextKeyboardFocusableActor) {
2139     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2140   } else {
2141     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2142     jdirection = (int)direction;
2143     jloopEnabled = loopEnabled;
2144     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2145     if (!jresult) {
2146       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2147       return c_result;
2148     }
2149     c_result = *(Dali::Actor *)jresult;
2150   }
2151   return c_result;
2152 }
2153
2154 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2155   void * jcommitedFocusableActor  ;
2156
2157   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2158     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2159     return;
2160   } else {
2161     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2162     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2163   }
2164 }
2165
2166 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2167   bool c_result = SwigValueInit< bool >() ;
2168   unsigned int jresult = 0 ;
2169
2170   if (!swig_callbackOnKeyboardEnter) {
2171     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2172   } else {
2173     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2174     c_result = jresult ? true : false;
2175   }
2176   return c_result;
2177 }
2178
2179 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2180   void * jpinch = 0 ;
2181
2182   if (!swig_callbackOnPinch) {
2183     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2184     return;
2185   } else {
2186     jpinch = (Dali::PinchGesture *) &pinch;
2187     swig_callbackOnPinch(jpinch);
2188   }
2189 }
2190
2191 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2192   void * jpan = 0 ;
2193
2194   if (!swig_callbackOnPan) {
2195     Dali::Toolkit::Internal::Control::OnPan(pan);
2196     return;
2197   } else {
2198     jpan = (Dali::PanGesture *) &pan;
2199     swig_callbackOnPan(jpan);
2200   }
2201 }
2202
2203 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2204   void * jtap = 0 ;
2205
2206   if (!swig_callbackOnTap) {
2207     Dali::Toolkit::Internal::Control::OnTap(tap);
2208     return;
2209   } else {
2210     jtap = (Dali::TapGesture *) &tap;
2211     swig_callbackOnTap(jtap);
2212   }
2213 }
2214
2215 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2216   void * jlongPress = 0 ;
2217
2218   if (!swig_callbackOnLongPress) {
2219     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2220     return;
2221   } else {
2222     jlongPress = (Dali::LongPressGesture *) &longPress;
2223     swig_callbackOnLongPress(jlongPress);
2224   }
2225 }
2226
2227 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2228   void * jslotObserver = 0 ;
2229   void * jcallback = 0 ;
2230
2231   if (!swig_callbackSignalConnected) {
2232     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2233     return;
2234   } else {
2235     jslotObserver = (void *) slotObserver;
2236     jcallback = (void *) callback;
2237     swig_callbackSignalConnected(jslotObserver, jcallback);
2238   }
2239 }
2240
2241 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2242   void * jslotObserver = 0 ;
2243   void * jcallback = 0 ;
2244
2245   if (!swig_callbackSignalDisconnected) {
2246     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2247     return;
2248   } else {
2249     jslotObserver = (void *) slotObserver;
2250     jcallback = (void *) callback;
2251     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2252   }
2253 }
2254
2255 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2256   return Dali::Toolkit::Internal::Control::GetControlExtension();
2257 }
2258
2259 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) {
2260   swig_callbackOnStageConnection = callbackOnStageConnection;
2261   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2262   swig_callbackOnChildAdd = callbackOnChildAdd;
2263   swig_callbackOnChildRemove = callbackOnChildRemove;
2264   swig_callbackOnPropertySet = callbackOnPropertySet;
2265   swig_callbackOnSizeSet = callbackOnSizeSet;
2266   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2267   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2268   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2269   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2270   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2271   swig_callbackOnRelayout = callbackOnRelayout;
2272   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2273   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2274   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2275   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2276   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2277   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2278   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2279   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2280   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2281   swig_callbackOnInitialize = callbackOnInitialize;
2282   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2283   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2284   swig_callbackOnStyleChange = callbackOnStyleChange;
2285   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2286   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2287   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2288   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2289   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2290   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2291   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2292   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2293   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2294   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2295   swig_callbackOnPinch = callbackOnPinch;
2296   swig_callbackOnPan = callbackOnPan;
2297   swig_callbackOnTap = callbackOnTap;
2298   swig_callbackOnLongPress = callbackOnLongPress;
2299   swig_callbackSignalConnected = callbackSignalConnected;
2300   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2301 }
2302
2303 void SwigDirector_ViewImpl::swig_init_callbacks() {
2304   swig_callbackOnStageConnection = 0;
2305   swig_callbackOnStageDisconnection = 0;
2306   swig_callbackOnChildAdd = 0;
2307   swig_callbackOnChildRemove = 0;
2308   swig_callbackOnPropertySet = 0;
2309   swig_callbackOnSizeSet = 0;
2310   swig_callbackOnSizeAnimation = 0;
2311   swig_callbackOnTouchEvent = 0;
2312   swig_callbackOnHoverEvent = 0;
2313   swig_callbackOnKeyEvent = 0;
2314   swig_callbackOnWheelEvent = 0;
2315   swig_callbackOnRelayout = 0;
2316   swig_callbackOnSetResizePolicy = 0;
2317   swig_callbackGetNaturalSize = 0;
2318   swig_callbackCalculateChildSize = 0;
2319   swig_callbackGetHeightForWidth = 0;
2320   swig_callbackGetWidthForHeight = 0;
2321   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2322   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2323   swig_callbackOnCalculateRelayoutSize = 0;
2324   swig_callbackOnLayoutNegotiated = 0;
2325   swig_callbackOnInitialize = 0;
2326   swig_callbackOnControlChildAdd = 0;
2327   swig_callbackOnControlChildRemove = 0;
2328   swig_callbackOnStyleChange = 0;
2329   swig_callbackOnAccessibilityActivated = 0;
2330   swig_callbackOnAccessibilityPan = 0;
2331   swig_callbackOnAccessibilityTouch = 0;
2332   swig_callbackOnAccessibilityValueChange = 0;
2333   swig_callbackOnAccessibilityZoom = 0;
2334   swig_callbackOnKeyInputFocusGained = 0;
2335   swig_callbackOnKeyInputFocusLost = 0;
2336   swig_callbackGetNextKeyboardFocusableActor = 0;
2337   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2338   swig_callbackOnKeyboardEnter = 0;
2339   swig_callbackOnPinch = 0;
2340   swig_callbackOnPan = 0;
2341   swig_callbackOnTap = 0;
2342   swig_callbackOnLongPress = 0;
2343   swig_callbackSignalConnected = 0;
2344   swig_callbackSignalDisconnected = 0;
2345 }
2346
2347 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2348   swig_init_callbacks();
2349 }
2350
2351 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2352
2353 }
2354
2355
2356 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2357   unsigned int c_result = SwigValueInit< unsigned int >() ;
2358   unsigned int jresult = 0 ;
2359
2360   if (!swig_callbackGetNumberOfItems) {
2361     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2362   } else {
2363     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2364     c_result = (unsigned int)jresult;
2365   }
2366   return c_result;
2367 }
2368
2369 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2370   Dali::Actor c_result ;
2371   void * jresult = 0 ;
2372   unsigned int jitemId  ;
2373
2374   if (!swig_callbackNewItem) {
2375     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2376   } else {
2377     jitemId = itemId;
2378     jresult = (void *) swig_callbackNewItem(jitemId);
2379     if (!jresult) {
2380       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2381       return c_result;
2382     }
2383     c_result = *(Dali::Actor *)jresult;
2384   }
2385   return c_result;
2386 }
2387
2388 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2389   unsigned int jitemId  ;
2390   void * jactor  ;
2391
2392   if (!swig_callbackItemReleased) {
2393     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2394     return;
2395   } else {
2396     jitemId = itemId;
2397     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2398     swig_callbackItemReleased(jitemId, jactor);
2399   }
2400 }
2401
2402 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2403   return Dali::Toolkit::ItemFactory::GetExtension();
2404 }
2405
2406 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2407   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2408   swig_callbackNewItem = callbackNewItem;
2409   swig_callbackItemReleased = callbackItemReleased;
2410 }
2411
2412 void SwigDirector_ItemFactory::swig_init_callbacks() {
2413   swig_callbackGetNumberOfItems = 0;
2414   swig_callbackNewItem = 0;
2415   swig_callbackItemReleased = 0;
2416 }
2417
2418 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2419   swig_init_callbacks();
2420 }
2421
2422 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2423
2424 }
2425
2426
2427 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2428   Dali::Actor c_result ;
2429   void * jresult = 0 ;
2430   void * jcurrent  ;
2431   void * jproposed  ;
2432   int jdirection  ;
2433
2434   if (!swig_callbackGetNextFocusableActor) {
2435     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2436   } else {
2437     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2438     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2439     jdirection = (int)direction;
2440     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2441     if (!jresult) {
2442       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2443       return c_result;
2444     }
2445     c_result = *(Dali::Actor *)jresult;
2446   }
2447   return c_result;
2448 }
2449
2450 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2451   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2452 }
2453
2454 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2455   swig_callbackGetNextFocusableActor = 0;
2456 }
2457
2458
2459 #ifdef __cplusplus
2460 extern "C" {
2461 #endif
2462
2463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2464   void * jresult ;
2465   floatp *result = 0 ;
2466
2467   {
2468     try {
2469       result = (floatp *)new_floatp();
2470     } catch (std::out_of_range& e) {
2471       {
2472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2473       };
2474     } catch (std::exception& e) {
2475       {
2476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2477       };
2478     } catch (...) {
2479       {
2480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2481       };
2482     }
2483   }
2484   jresult = (void *)result;
2485   return jresult;
2486 }
2487
2488
2489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2490   floatp *arg1 = (floatp *) 0 ;
2491
2492   arg1 = (floatp *)jarg1;
2493   {
2494     try {
2495       delete_floatp(arg1);
2496     } catch (std::out_of_range& e) {
2497       {
2498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2499       };
2500     } catch (std::exception& e) {
2501       {
2502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2503       };
2504     } catch (...) {
2505       {
2506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2507       };
2508     }
2509   }
2510 }
2511
2512
2513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2514   floatp *arg1 = (floatp *) 0 ;
2515   float arg2 ;
2516
2517   arg1 = (floatp *)jarg1;
2518   arg2 = (float)jarg2;
2519   {
2520     try {
2521       floatp_assign(arg1,arg2);
2522     } catch (std::out_of_range& e) {
2523       {
2524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2525       };
2526     } catch (std::exception& e) {
2527       {
2528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2529       };
2530     } catch (...) {
2531       {
2532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2533       };
2534     }
2535   }
2536 }
2537
2538
2539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2540   float jresult ;
2541   floatp *arg1 = (floatp *) 0 ;
2542   float result;
2543
2544   arg1 = (floatp *)jarg1;
2545   {
2546     try {
2547       result = (float)floatp_value(arg1);
2548     } catch (std::out_of_range& e) {
2549       {
2550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2551       };
2552     } catch (std::exception& e) {
2553       {
2554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2555       };
2556     } catch (...) {
2557       {
2558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2559       };
2560     }
2561   }
2562   jresult = result;
2563   return jresult;
2564 }
2565
2566
2567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2568   void * jresult ;
2569   floatp *arg1 = (floatp *) 0 ;
2570   float *result = 0 ;
2571
2572   arg1 = (floatp *)jarg1;
2573   {
2574     try {
2575       result = (float *)floatp_cast(arg1);
2576     } catch (std::out_of_range& e) {
2577       {
2578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2579       };
2580     } catch (std::exception& e) {
2581       {
2582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2583       };
2584     } catch (...) {
2585       {
2586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2587       };
2588     }
2589   }
2590   jresult = (void *)result;
2591   return jresult;
2592 }
2593
2594
2595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2596   void * jresult ;
2597   float *arg1 = (float *) 0 ;
2598   floatp *result = 0 ;
2599
2600   arg1 = (float *)jarg1;
2601   {
2602     try {
2603       result = (floatp *)floatp_frompointer(arg1);
2604     } catch (std::out_of_range& e) {
2605       {
2606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2607       };
2608     } catch (std::exception& e) {
2609       {
2610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2611       };
2612     } catch (...) {
2613       {
2614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2615       };
2616     }
2617   }
2618   jresult = (void *)result;
2619   return jresult;
2620 }
2621
2622
2623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2624   void * jresult ;
2625   intp *result = 0 ;
2626
2627   {
2628     try {
2629       result = (intp *)new_intp();
2630     } catch (std::out_of_range& e) {
2631       {
2632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2633       };
2634     } catch (std::exception& e) {
2635       {
2636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2637       };
2638     } catch (...) {
2639       {
2640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2641       };
2642     }
2643   }
2644   jresult = (void *)result;
2645   return jresult;
2646 }
2647
2648
2649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2650   intp *arg1 = (intp *) 0 ;
2651
2652   arg1 = (intp *)jarg1;
2653   {
2654     try {
2655       delete_intp(arg1);
2656     } catch (std::out_of_range& e) {
2657       {
2658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2659       };
2660     } catch (std::exception& e) {
2661       {
2662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2663       };
2664     } catch (...) {
2665       {
2666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2667       };
2668     }
2669   }
2670 }
2671
2672
2673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2674   intp *arg1 = (intp *) 0 ;
2675   int arg2 ;
2676
2677   arg1 = (intp *)jarg1;
2678   arg2 = (int)jarg2;
2679   {
2680     try {
2681       intp_assign(arg1,arg2);
2682     } catch (std::out_of_range& e) {
2683       {
2684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2685       };
2686     } catch (std::exception& e) {
2687       {
2688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2689       };
2690     } catch (...) {
2691       {
2692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2693       };
2694     }
2695   }
2696 }
2697
2698
2699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2700   int jresult ;
2701   intp *arg1 = (intp *) 0 ;
2702   int result;
2703
2704   arg1 = (intp *)jarg1;
2705   {
2706     try {
2707       result = (int)intp_value(arg1);
2708     } catch (std::out_of_range& e) {
2709       {
2710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2711       };
2712     } catch (std::exception& e) {
2713       {
2714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2715       };
2716     } catch (...) {
2717       {
2718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2719       };
2720     }
2721   }
2722   jresult = result;
2723   return jresult;
2724 }
2725
2726
2727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2728   void * jresult ;
2729   intp *arg1 = (intp *) 0 ;
2730   int *result = 0 ;
2731
2732   arg1 = (intp *)jarg1;
2733   {
2734     try {
2735       result = (int *)intp_cast(arg1);
2736     } catch (std::out_of_range& e) {
2737       {
2738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2739       };
2740     } catch (std::exception& e) {
2741       {
2742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2743       };
2744     } catch (...) {
2745       {
2746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2747       };
2748     }
2749   }
2750   jresult = (void *)result;
2751   return jresult;
2752 }
2753
2754
2755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2756   void * jresult ;
2757   int *arg1 = (int *) 0 ;
2758   intp *result = 0 ;
2759
2760   arg1 = (int *)jarg1;
2761   {
2762     try {
2763       result = (intp *)intp_frompointer(arg1);
2764     } catch (std::out_of_range& e) {
2765       {
2766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2767       };
2768     } catch (std::exception& e) {
2769       {
2770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2771       };
2772     } catch (...) {
2773       {
2774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2775       };
2776     }
2777   }
2778   jresult = (void *)result;
2779   return jresult;
2780 }
2781
2782
2783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2784   void * jresult ;
2785   doublep *result = 0 ;
2786
2787   {
2788     try {
2789       result = (doublep *)new_doublep();
2790     } catch (std::out_of_range& e) {
2791       {
2792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2793       };
2794     } catch (std::exception& e) {
2795       {
2796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2797       };
2798     } catch (...) {
2799       {
2800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2801       };
2802     }
2803   }
2804   jresult = (void *)result;
2805   return jresult;
2806 }
2807
2808
2809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2810   doublep *arg1 = (doublep *) 0 ;
2811
2812   arg1 = (doublep *)jarg1;
2813   {
2814     try {
2815       delete_doublep(arg1);
2816     } catch (std::out_of_range& e) {
2817       {
2818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2819       };
2820     } catch (std::exception& e) {
2821       {
2822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2823       };
2824     } catch (...) {
2825       {
2826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2827       };
2828     }
2829   }
2830 }
2831
2832
2833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2834   doublep *arg1 = (doublep *) 0 ;
2835   double arg2 ;
2836
2837   arg1 = (doublep *)jarg1;
2838   arg2 = (double)jarg2;
2839   {
2840     try {
2841       doublep_assign(arg1,arg2);
2842     } catch (std::out_of_range& e) {
2843       {
2844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2845       };
2846     } catch (std::exception& e) {
2847       {
2848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2849       };
2850     } catch (...) {
2851       {
2852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2853       };
2854     }
2855   }
2856 }
2857
2858
2859 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
2860   double jresult ;
2861   doublep *arg1 = (doublep *) 0 ;
2862   double result;
2863
2864   arg1 = (doublep *)jarg1;
2865   {
2866     try {
2867       result = (double)doublep_value(arg1);
2868     } catch (std::out_of_range& e) {
2869       {
2870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2871       };
2872     } catch (std::exception& e) {
2873       {
2874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2875       };
2876     } catch (...) {
2877       {
2878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2879       };
2880     }
2881   }
2882   jresult = result;
2883   return jresult;
2884 }
2885
2886
2887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
2888   void * jresult ;
2889   doublep *arg1 = (doublep *) 0 ;
2890   double *result = 0 ;
2891
2892   arg1 = (doublep *)jarg1;
2893   {
2894     try {
2895       result = (double *)doublep_cast(arg1);
2896     } catch (std::out_of_range& e) {
2897       {
2898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2899       };
2900     } catch (std::exception& e) {
2901       {
2902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2903       };
2904     } catch (...) {
2905       {
2906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2907       };
2908     }
2909   }
2910   jresult = (void *)result;
2911   return jresult;
2912 }
2913
2914
2915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
2916   void * jresult ;
2917   double *arg1 = (double *) 0 ;
2918   doublep *result = 0 ;
2919
2920   arg1 = (double *)jarg1;
2921   {
2922     try {
2923       result = (doublep *)doublep_frompointer(arg1);
2924     } catch (std::out_of_range& e) {
2925       {
2926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2927       };
2928     } catch (std::exception& e) {
2929       {
2930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2931       };
2932     } catch (...) {
2933       {
2934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2935       };
2936     }
2937   }
2938   jresult = (void *)result;
2939   return jresult;
2940 }
2941
2942
2943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
2944   void * jresult ;
2945   uintp *result = 0 ;
2946
2947   {
2948     try {
2949       result = (uintp *)new_uintp();
2950     } catch (std::out_of_range& e) {
2951       {
2952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2953       };
2954     } catch (std::exception& e) {
2955       {
2956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2957       };
2958     } catch (...) {
2959       {
2960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2961       };
2962     }
2963   }
2964   jresult = (void *)result;
2965   return jresult;
2966 }
2967
2968
2969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
2970   uintp *arg1 = (uintp *) 0 ;
2971
2972   arg1 = (uintp *)jarg1;
2973   {
2974     try {
2975       delete_uintp(arg1);
2976     } catch (std::out_of_range& e) {
2977       {
2978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2979       };
2980     } catch (std::exception& e) {
2981       {
2982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2983       };
2984     } catch (...) {
2985       {
2986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2987       };
2988     }
2989   }
2990 }
2991
2992
2993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
2994   uintp *arg1 = (uintp *) 0 ;
2995   unsigned int arg2 ;
2996
2997   arg1 = (uintp *)jarg1;
2998   arg2 = (unsigned int)jarg2;
2999   {
3000     try {
3001       uintp_assign(arg1,arg2);
3002     } catch (std::out_of_range& e) {
3003       {
3004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3005       };
3006     } catch (std::exception& e) {
3007       {
3008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3009       };
3010     } catch (...) {
3011       {
3012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3013       };
3014     }
3015   }
3016 }
3017
3018
3019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3020   unsigned int jresult ;
3021   uintp *arg1 = (uintp *) 0 ;
3022   unsigned int result;
3023
3024   arg1 = (uintp *)jarg1;
3025   {
3026     try {
3027       result = (unsigned int)uintp_value(arg1);
3028     } catch (std::out_of_range& e) {
3029       {
3030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3031       };
3032     } catch (std::exception& e) {
3033       {
3034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3035       };
3036     } catch (...) {
3037       {
3038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3039       };
3040     }
3041   }
3042   jresult = result;
3043   return jresult;
3044 }
3045
3046
3047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3048   void * jresult ;
3049   uintp *arg1 = (uintp *) 0 ;
3050   unsigned int *result = 0 ;
3051
3052   arg1 = (uintp *)jarg1;
3053   {
3054     try {
3055       result = (unsigned int *)uintp_cast(arg1);
3056     } catch (std::out_of_range& e) {
3057       {
3058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3059       };
3060     } catch (std::exception& e) {
3061       {
3062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3063       };
3064     } catch (...) {
3065       {
3066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3067       };
3068     }
3069   }
3070   jresult = (void *)result;
3071   return jresult;
3072 }
3073
3074
3075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3076   void * jresult ;
3077   unsigned int *arg1 = (unsigned int *) 0 ;
3078   uintp *result = 0 ;
3079
3080   arg1 = (unsigned int *)jarg1;
3081   {
3082     try {
3083       result = (uintp *)uintp_frompointer(arg1);
3084     } catch (std::out_of_range& e) {
3085       {
3086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3087       };
3088     } catch (std::exception& e) {
3089       {
3090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3091       };
3092     } catch (...) {
3093       {
3094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3095       };
3096     }
3097   }
3098   jresult = (void *)result;
3099   return jresult;
3100 }
3101
3102
3103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3104   void * jresult ;
3105   ushortp *result = 0 ;
3106
3107   {
3108     try {
3109       result = (ushortp *)new_ushortp();
3110     } catch (std::out_of_range& e) {
3111       {
3112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3113       };
3114     } catch (std::exception& e) {
3115       {
3116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3117       };
3118     } catch (...) {
3119       {
3120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3121       };
3122     }
3123   }
3124   jresult = (void *)result;
3125   return jresult;
3126 }
3127
3128
3129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3130   ushortp *arg1 = (ushortp *) 0 ;
3131
3132   arg1 = (ushortp *)jarg1;
3133   {
3134     try {
3135       delete_ushortp(arg1);
3136     } catch (std::out_of_range& e) {
3137       {
3138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3139       };
3140     } catch (std::exception& e) {
3141       {
3142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3143       };
3144     } catch (...) {
3145       {
3146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3147       };
3148     }
3149   }
3150 }
3151
3152
3153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3154   ushortp *arg1 = (ushortp *) 0 ;
3155   unsigned short arg2 ;
3156
3157   arg1 = (ushortp *)jarg1;
3158   arg2 = (unsigned short)jarg2;
3159   {
3160     try {
3161       ushortp_assign(arg1,arg2);
3162     } catch (std::out_of_range& e) {
3163       {
3164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3165       };
3166     } catch (std::exception& e) {
3167       {
3168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3169       };
3170     } catch (...) {
3171       {
3172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3173       };
3174     }
3175   }
3176 }
3177
3178
3179 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3180   unsigned short jresult ;
3181   ushortp *arg1 = (ushortp *) 0 ;
3182   unsigned short result;
3183
3184   arg1 = (ushortp *)jarg1;
3185   {
3186     try {
3187       result = (unsigned short)ushortp_value(arg1);
3188     } catch (std::out_of_range& e) {
3189       {
3190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3191       };
3192     } catch (std::exception& e) {
3193       {
3194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3195       };
3196     } catch (...) {
3197       {
3198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3199       };
3200     }
3201   }
3202   jresult = result;
3203   return jresult;
3204 }
3205
3206
3207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3208   void * jresult ;
3209   ushortp *arg1 = (ushortp *) 0 ;
3210   unsigned short *result = 0 ;
3211
3212   arg1 = (ushortp *)jarg1;
3213   {
3214     try {
3215       result = (unsigned short *)ushortp_cast(arg1);
3216     } catch (std::out_of_range& e) {
3217       {
3218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3219       };
3220     } catch (std::exception& e) {
3221       {
3222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3223       };
3224     } catch (...) {
3225       {
3226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3227       };
3228     }
3229   }
3230   jresult = (void *)result;
3231   return jresult;
3232 }
3233
3234
3235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3236   void * jresult ;
3237   unsigned short *arg1 = (unsigned short *) 0 ;
3238   ushortp *result = 0 ;
3239
3240   arg1 = (unsigned short *)jarg1;
3241   {
3242     try {
3243       result = (ushortp *)ushortp_frompointer(arg1);
3244     } catch (std::out_of_range& e) {
3245       {
3246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3247       };
3248     } catch (std::exception& e) {
3249       {
3250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3251       };
3252     } catch (...) {
3253       {
3254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3255       };
3256     }
3257   }
3258   jresult = (void *)result;
3259   return jresult;
3260 }
3261
3262
3263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3264   unsigned int jresult ;
3265   int arg1 ;
3266   unsigned int result;
3267
3268   arg1 = (int)jarg1;
3269   {
3270     try {
3271       result = (unsigned int)int_to_uint(arg1);
3272     } catch (std::out_of_range& e) {
3273       {
3274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3275       };
3276     } catch (std::exception& e) {
3277       {
3278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3279       };
3280     } catch (...) {
3281       {
3282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3283       };
3284     }
3285   }
3286   jresult = result;
3287   return jresult;
3288 }
3289
3290
3291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3292   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3293
3294   arg1 = (Dali::RefObject *)jarg1;
3295   {
3296     try {
3297       (arg1)->Reference();
3298     } catch (std::out_of_range& e) {
3299       {
3300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3301       };
3302     } catch (std::exception& e) {
3303       {
3304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3305       };
3306     } catch (...) {
3307       {
3308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3309       };
3310     }
3311   }
3312 }
3313
3314
3315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3316   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3317
3318   arg1 = (Dali::RefObject *)jarg1;
3319   {
3320     try {
3321       (arg1)->Unreference();
3322     } catch (std::out_of_range& e) {
3323       {
3324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3325       };
3326     } catch (std::exception& e) {
3327       {
3328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3329       };
3330     } catch (...) {
3331       {
3332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3333       };
3334     }
3335   }
3336 }
3337
3338
3339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3340   int jresult ;
3341   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3342   int result;
3343
3344   arg1 = (Dali::RefObject *)jarg1;
3345   {
3346     try {
3347       result = (int)(arg1)->ReferenceCount();
3348     } catch (std::out_of_range& e) {
3349       {
3350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3351       };
3352     } catch (std::exception& e) {
3353       {
3354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3355       };
3356     } catch (...) {
3357       {
3358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3359       };
3360     }
3361   }
3362   jresult = result;
3363   return jresult;
3364 }
3365
3366
3367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3368   void * jresult ;
3369   Dali::Any *result = 0 ;
3370
3371   {
3372     try {
3373       result = (Dali::Any *)new Dali::Any();
3374     } catch (std::out_of_range& e) {
3375       {
3376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3377       };
3378     } catch (std::exception& e) {
3379       {
3380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3381       };
3382     } catch (...) {
3383       {
3384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3385       };
3386     }
3387   }
3388   jresult = (void *)result;
3389   return jresult;
3390 }
3391
3392
3393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3394   Dali::Any *arg1 = (Dali::Any *) 0 ;
3395
3396   arg1 = (Dali::Any *)jarg1;
3397   {
3398     try {
3399       delete arg1;
3400     } catch (std::out_of_range& e) {
3401       {
3402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3403       };
3404     } catch (std::exception& e) {
3405       {
3406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3407       };
3408     } catch (...) {
3409       {
3410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3411       };
3412     }
3413   }
3414 }
3415
3416
3417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3418   char *arg1 = (char *) 0 ;
3419
3420   arg1 = (char *)jarg1;
3421   {
3422     try {
3423       Dali::Any::AssertAlways((char const *)arg1);
3424     } catch (std::out_of_range& e) {
3425       {
3426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3427       };
3428     } catch (std::exception& e) {
3429       {
3430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3431       };
3432     } catch (...) {
3433       {
3434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3435       };
3436     }
3437   }
3438 }
3439
3440
3441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3442   void * jresult ;
3443   Dali::Any *arg1 = 0 ;
3444   Dali::Any *result = 0 ;
3445
3446   arg1 = (Dali::Any *)jarg1;
3447   if (!arg1) {
3448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3449     return 0;
3450   }
3451   {
3452     try {
3453       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3454     } catch (std::out_of_range& e) {
3455       {
3456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3457       };
3458     } catch (std::exception& e) {
3459       {
3460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3461       };
3462     } catch (...) {
3463       {
3464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3465       };
3466     }
3467   }
3468   jresult = (void *)result;
3469   return jresult;
3470 }
3471
3472
3473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3474   void * jresult ;
3475   Dali::Any *arg1 = (Dali::Any *) 0 ;
3476   Dali::Any *arg2 = 0 ;
3477   Dali::Any *result = 0 ;
3478
3479   arg1 = (Dali::Any *)jarg1;
3480   arg2 = (Dali::Any *)jarg2;
3481   if (!arg2) {
3482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3483     return 0;
3484   }
3485   {
3486     try {
3487       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3488     } catch (std::out_of_range& e) {
3489       {
3490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3491       };
3492     } catch (std::exception& e) {
3493       {
3494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3495       };
3496     } catch (...) {
3497       {
3498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3499       };
3500     }
3501   }
3502   jresult = (void *)result;
3503   return jresult;
3504 }
3505
3506
3507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3508   void * jresult ;
3509   Dali::Any *arg1 = (Dali::Any *) 0 ;
3510   std::type_info *result = 0 ;
3511
3512   arg1 = (Dali::Any *)jarg1;
3513   {
3514     try {
3515       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3516     } catch (std::out_of_range& e) {
3517       {
3518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3519       };
3520     } catch (std::exception& e) {
3521       {
3522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3523       };
3524     } catch (...) {
3525       {
3526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3527       };
3528     }
3529   }
3530   jresult = (void *)result;
3531   return jresult;
3532 }
3533
3534
3535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3536   unsigned int jresult ;
3537   Dali::Any *arg1 = (Dali::Any *) 0 ;
3538   bool result;
3539
3540   arg1 = (Dali::Any *)jarg1;
3541   {
3542     try {
3543       result = (bool)((Dali::Any const *)arg1)->Empty();
3544     } catch (std::out_of_range& e) {
3545       {
3546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3547       };
3548     } catch (std::exception& e) {
3549       {
3550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3551       };
3552     } catch (...) {
3553       {
3554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3555       };
3556     }
3557   }
3558   jresult = result;
3559   return jresult;
3560 }
3561
3562
3563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3564   void * jresult ;
3565   std::type_info *arg1 = 0 ;
3566   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3567   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3568   Dali::Any::AnyContainerBase *result = 0 ;
3569
3570   arg1 = (std::type_info *)jarg1;
3571   if (!arg1) {
3572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3573     return 0;
3574   }
3575   arg2 = (Dali::Any::CloneFunc)jarg2;
3576   arg3 = (Dali::Any::DeleteFunc)jarg3;
3577   {
3578     try {
3579       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3580     } catch (std::out_of_range& e) {
3581       {
3582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3583       };
3584     } catch (std::exception& e) {
3585       {
3586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3587       };
3588     } catch (...) {
3589       {
3590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3591       };
3592     }
3593   }
3594   jresult = (void *)result;
3595   return jresult;
3596 }
3597
3598
3599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3600   void * jresult ;
3601   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3602   std::type_info *result = 0 ;
3603
3604   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3605   {
3606     try {
3607       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3608     } catch (std::out_of_range& e) {
3609       {
3610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3611       };
3612     } catch (std::exception& e) {
3613       {
3614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3615       };
3616     } catch (...) {
3617       {
3618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3619       };
3620     }
3621   }
3622   jresult = (void *)result;
3623   return jresult;
3624 }
3625
3626
3627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3628   void * jresult ;
3629   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3630   ::std::type_info *result = 0 ;
3631
3632   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3633   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3634   jresult = (void *)result;
3635   return jresult;
3636 }
3637
3638
3639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3640   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3641   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3642
3643   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3644   arg2 = (Dali::Any::CloneFunc)jarg2;
3645   if (arg1) (arg1)->mCloneFunc = arg2;
3646 }
3647
3648
3649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3650   void * jresult ;
3651   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3652   Dali::Any::CloneFunc result;
3653
3654   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3655   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3656   jresult = (void *)result;
3657   return jresult;
3658 }
3659
3660
3661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3662   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3663   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3664
3665   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3666   arg2 = (Dali::Any::DeleteFunc)jarg2;
3667   if (arg1) (arg1)->mDeleteFunc = arg2;
3668 }
3669
3670
3671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3672   void * jresult ;
3673   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3674   Dali::Any::DeleteFunc result;
3675
3676   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3677   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3678   jresult = (void *)result;
3679   return jresult;
3680 }
3681
3682
3683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3684   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3685
3686   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3687   {
3688     try {
3689       delete arg1;
3690     } catch (std::out_of_range& e) {
3691       {
3692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3693       };
3694     } catch (std::exception& e) {
3695       {
3696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3697       };
3698     } catch (...) {
3699       {
3700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3701       };
3702     }
3703   }
3704 }
3705
3706
3707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
3708   Dali::Any *arg1 = (Dali::Any *) 0 ;
3709   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
3710
3711   arg1 = (Dali::Any *)jarg1;
3712   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
3713   if (arg1) (arg1)->mContainer = arg2;
3714 }
3715
3716
3717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
3718   void * jresult ;
3719   Dali::Any *arg1 = (Dali::Any *) 0 ;
3720   Dali::Any::AnyContainerBase *result = 0 ;
3721
3722   arg1 = (Dali::Any *)jarg1;
3723   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
3724   jresult = (void *)result;
3725   return jresult;
3726 }
3727
3728
3729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
3730   char *arg1 = (char *) 0 ;
3731   char *arg2 = (char *) 0 ;
3732
3733   arg1 = (char *)jarg1;
3734   arg2 = (char *)jarg2;
3735   {
3736     try {
3737       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
3738     } catch (std::out_of_range& e) {
3739       {
3740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3741       };
3742     } catch (std::exception& e) {
3743       {
3744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3745       };
3746     } catch (...) {
3747       {
3748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3749       };
3750     }
3751   }
3752 }
3753
3754
3755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
3756   void * jresult ;
3757   char *arg1 = (char *) 0 ;
3758   char *arg2 = (char *) 0 ;
3759   Dali::DaliException *result = 0 ;
3760
3761   arg1 = (char *)jarg1;
3762   arg2 = (char *)jarg2;
3763   {
3764     try {
3765       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
3766     } catch (std::out_of_range& e) {
3767       {
3768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3769       };
3770     } catch (std::exception& e) {
3771       {
3772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3773       };
3774     } catch (...) {
3775       {
3776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3777       };
3778     }
3779   }
3780   jresult = (void *)result;
3781   return jresult;
3782 }
3783
3784
3785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
3786   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3787   char *arg2 = (char *) 0 ;
3788
3789   arg1 = (Dali::DaliException *)jarg1;
3790   arg2 = (char *)jarg2;
3791   {
3792     if (arg2) {
3793       arg1->location = (char const *) (new char[strlen((const char *)arg2)+1]);
3794       strcpy((char *)arg1->location, (const char *)arg2);
3795     } else {
3796       arg1->location = 0;
3797     }
3798   }
3799 }
3800
3801
3802 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
3803   char * jresult ;
3804   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3805   char *result = 0 ;
3806
3807   arg1 = (Dali::DaliException *)jarg1;
3808   result = (char *) ((arg1)->location);
3809   jresult = SWIG_csharp_string_callback((const char *)result);
3810   return jresult;
3811 }
3812
3813
3814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
3815   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3816   char *arg2 = (char *) 0 ;
3817
3818   arg1 = (Dali::DaliException *)jarg1;
3819   arg2 = (char *)jarg2;
3820   {
3821     if (arg2) {
3822       arg1->condition = (char const *) (new char[strlen((const char *)arg2)+1]);
3823       strcpy((char *)arg1->condition, (const char *)arg2);
3824     } else {
3825       arg1->condition = 0;
3826     }
3827   }
3828 }
3829
3830
3831 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
3832   char * jresult ;
3833   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3834   char *result = 0 ;
3835
3836   arg1 = (Dali::DaliException *)jarg1;
3837   result = (char *) ((arg1)->condition);
3838   jresult = SWIG_csharp_string_callback((const char *)result);
3839   return jresult;
3840 }
3841
3842
3843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
3844   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
3845
3846   arg1 = (Dali::DaliException *)jarg1;
3847   {
3848     try {
3849       delete arg1;
3850     } catch (std::out_of_range& e) {
3851       {
3852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3853       };
3854     } catch (std::exception& e) {
3855       {
3856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3857       };
3858     } catch (...) {
3859       {
3860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3861       };
3862     }
3863   }
3864 }
3865
3866
3867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
3868   void * jresult ;
3869   Dali::Vector2 *result = 0 ;
3870
3871   {
3872     try {
3873       result = (Dali::Vector2 *)new Dali::Vector2();
3874     } catch (std::out_of_range& e) {
3875       {
3876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3877       };
3878     } catch (std::exception& e) {
3879       {
3880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3881       };
3882     } catch (...) {
3883       {
3884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3885       };
3886     }
3887   }
3888   jresult = (void *)result;
3889   return jresult;
3890 }
3891
3892
3893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
3894   void * jresult ;
3895   float arg1 ;
3896   float arg2 ;
3897   Dali::Vector2 *result = 0 ;
3898
3899   arg1 = (float)jarg1;
3900   arg2 = (float)jarg2;
3901   {
3902     try {
3903       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
3904     } catch (std::out_of_range& e) {
3905       {
3906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3907       };
3908     } catch (std::exception& e) {
3909       {
3910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3911       };
3912     } catch (...) {
3913       {
3914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3915       };
3916     }
3917   }
3918   jresult = (void *)result;
3919   return jresult;
3920 }
3921
3922
3923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
3924   void * jresult ;
3925   float *arg1 = (float *) 0 ;
3926   Dali::Vector2 *result = 0 ;
3927
3928   arg1 = jarg1;
3929   {
3930     try {
3931       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
3932     } catch (std::out_of_range& e) {
3933       {
3934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3935       };
3936     } catch (std::exception& e) {
3937       {
3938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3939       };
3940     } catch (...) {
3941       {
3942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3943       };
3944     }
3945   }
3946   jresult = (void *)result;
3947
3948
3949   return jresult;
3950 }
3951
3952
3953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
3954   void * jresult ;
3955   Dali::Vector3 *arg1 = 0 ;
3956   Dali::Vector2 *result = 0 ;
3957
3958   arg1 = (Dali::Vector3 *)jarg1;
3959   if (!arg1) {
3960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
3961     return 0;
3962   }
3963   {
3964     try {
3965       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
3966     } catch (std::out_of_range& e) {
3967       {
3968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3969       };
3970     } catch (std::exception& e) {
3971       {
3972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3973       };
3974     } catch (...) {
3975       {
3976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3977       };
3978     }
3979   }
3980   jresult = (void *)result;
3981   return jresult;
3982 }
3983
3984
3985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
3986   void * jresult ;
3987   Dali::Vector4 *arg1 = 0 ;
3988   Dali::Vector2 *result = 0 ;
3989
3990   arg1 = (Dali::Vector4 *)jarg1;
3991   if (!arg1) {
3992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
3993     return 0;
3994   }
3995   {
3996     try {
3997       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
3998     } catch (std::out_of_range& e) {
3999       {
4000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4001       };
4002     } catch (std::exception& e) {
4003       {
4004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4005       };
4006     } catch (...) {
4007       {
4008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4009       };
4010     }
4011   }
4012   jresult = (void *)result;
4013   return jresult;
4014 }
4015
4016
4017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4018   void * jresult ;
4019   Dali::Vector2 *result = 0 ;
4020
4021   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4022   jresult = (void *)result;
4023   return jresult;
4024 }
4025
4026
4027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4028   void * jresult ;
4029   Dali::Vector2 *result = 0 ;
4030
4031   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4032   jresult = (void *)result;
4033   return jresult;
4034 }
4035
4036
4037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4038   void * jresult ;
4039   Dali::Vector2 *result = 0 ;
4040
4041   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4042   jresult = (void *)result;
4043   return jresult;
4044 }
4045
4046
4047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4048   void * jresult ;
4049   Dali::Vector2 *result = 0 ;
4050
4051   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4052   jresult = (void *)result;
4053   return jresult;
4054 }
4055
4056
4057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4058   void * jresult ;
4059   Dali::Vector2 *result = 0 ;
4060
4061   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4062   jresult = (void *)result;
4063   return jresult;
4064 }
4065
4066
4067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4068   void * jresult ;
4069   Dali::Vector2 *result = 0 ;
4070
4071   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4072   jresult = (void *)result;
4073   return jresult;
4074 }
4075
4076
4077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4078   void * jresult ;
4079   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4080   float *arg2 = (float *) 0 ;
4081   Dali::Vector2 *result = 0 ;
4082
4083   arg1 = (Dali::Vector2 *)jarg1;
4084   arg2 = jarg2;
4085   {
4086     try {
4087       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4088     } catch (std::out_of_range& e) {
4089       {
4090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4091       };
4092     } catch (std::exception& e) {
4093       {
4094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4095       };
4096     } catch (...) {
4097       {
4098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4099       };
4100     }
4101   }
4102   jresult = (void *)result;
4103
4104
4105   return jresult;
4106 }
4107
4108
4109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4110   void * jresult ;
4111   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4112   Dali::Vector3 *arg2 = 0 ;
4113   Dali::Vector2 *result = 0 ;
4114
4115   arg1 = (Dali::Vector2 *)jarg1;
4116   arg2 = (Dali::Vector3 *)jarg2;
4117   if (!arg2) {
4118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4119     return 0;
4120   }
4121   {
4122     try {
4123       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4124     } catch (std::out_of_range& e) {
4125       {
4126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4127       };
4128     } catch (std::exception& e) {
4129       {
4130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4131       };
4132     } catch (...) {
4133       {
4134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4135       };
4136     }
4137   }
4138   jresult = (void *)result;
4139   return jresult;
4140 }
4141
4142
4143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4144   void * jresult ;
4145   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4146   Dali::Vector4 *arg2 = 0 ;
4147   Dali::Vector2 *result = 0 ;
4148
4149   arg1 = (Dali::Vector2 *)jarg1;
4150   arg2 = (Dali::Vector4 *)jarg2;
4151   if (!arg2) {
4152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4153     return 0;
4154   }
4155   {
4156     try {
4157       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4158     } catch (std::out_of_range& e) {
4159       {
4160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4161       };
4162     } catch (std::exception& e) {
4163       {
4164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4165       };
4166     } catch (...) {
4167       {
4168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4169       };
4170     }
4171   }
4172   jresult = (void *)result;
4173   return jresult;
4174 }
4175
4176
4177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4178   void * jresult ;
4179   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4180   Dali::Vector2 *arg2 = 0 ;
4181   Dali::Vector2 result;
4182
4183   arg1 = (Dali::Vector2 *)jarg1;
4184   arg2 = (Dali::Vector2 *)jarg2;
4185   if (!arg2) {
4186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4187     return 0;
4188   }
4189   {
4190     try {
4191       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4192     } catch (std::out_of_range& e) {
4193       {
4194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4195       };
4196     } catch (std::exception& e) {
4197       {
4198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4199       };
4200     } catch (...) {
4201       {
4202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4203       };
4204     }
4205   }
4206   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4207   return jresult;
4208 }
4209
4210
4211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4212   void * jresult ;
4213   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4214   Dali::Vector2 *arg2 = 0 ;
4215   Dali::Vector2 *result = 0 ;
4216
4217   arg1 = (Dali::Vector2 *)jarg1;
4218   arg2 = (Dali::Vector2 *)jarg2;
4219   if (!arg2) {
4220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4221     return 0;
4222   }
4223   {
4224     try {
4225       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4226     } catch (std::out_of_range& e) {
4227       {
4228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4229       };
4230     } catch (std::exception& e) {
4231       {
4232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4233       };
4234     } catch (...) {
4235       {
4236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4237       };
4238     }
4239   }
4240   jresult = (void *)result;
4241   return jresult;
4242 }
4243
4244
4245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4246   void * jresult ;
4247   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4248   Dali::Vector2 *arg2 = 0 ;
4249   Dali::Vector2 result;
4250
4251   arg1 = (Dali::Vector2 *)jarg1;
4252   arg2 = (Dali::Vector2 *)jarg2;
4253   if (!arg2) {
4254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4255     return 0;
4256   }
4257   {
4258     try {
4259       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4260     } catch (std::out_of_range& e) {
4261       {
4262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4263       };
4264     } catch (std::exception& e) {
4265       {
4266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4267       };
4268     } catch (...) {
4269       {
4270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4271       };
4272     }
4273   }
4274   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4275   return jresult;
4276 }
4277
4278
4279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4280   void * jresult ;
4281   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4282   Dali::Vector2 *arg2 = 0 ;
4283   Dali::Vector2 *result = 0 ;
4284
4285   arg1 = (Dali::Vector2 *)jarg1;
4286   arg2 = (Dali::Vector2 *)jarg2;
4287   if (!arg2) {
4288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4289     return 0;
4290   }
4291   {
4292     try {
4293       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4294     } catch (std::out_of_range& e) {
4295       {
4296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4297       };
4298     } catch (std::exception& e) {
4299       {
4300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4301       };
4302     } catch (...) {
4303       {
4304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4305       };
4306     }
4307   }
4308   jresult = (void *)result;
4309   return jresult;
4310 }
4311
4312
4313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4314   void * jresult ;
4315   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4316   Dali::Vector2 *arg2 = 0 ;
4317   Dali::Vector2 result;
4318
4319   arg1 = (Dali::Vector2 *)jarg1;
4320   arg2 = (Dali::Vector2 *)jarg2;
4321   if (!arg2) {
4322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4323     return 0;
4324   }
4325   {
4326     try {
4327       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4328     } catch (std::out_of_range& e) {
4329       {
4330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4331       };
4332     } catch (std::exception& e) {
4333       {
4334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4335       };
4336     } catch (...) {
4337       {
4338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4339       };
4340     }
4341   }
4342   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4343   return jresult;
4344 }
4345
4346
4347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4348   void * jresult ;
4349   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4350   float arg2 ;
4351   Dali::Vector2 result;
4352
4353   arg1 = (Dali::Vector2 *)jarg1;
4354   arg2 = (float)jarg2;
4355   {
4356     try {
4357       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4358     } catch (std::out_of_range& e) {
4359       {
4360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4361       };
4362     } catch (std::exception& e) {
4363       {
4364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4365       };
4366     } catch (...) {
4367       {
4368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4369       };
4370     }
4371   }
4372   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4373   return jresult;
4374 }
4375
4376
4377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4378   void * jresult ;
4379   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4380   Dali::Vector2 *arg2 = 0 ;
4381   Dali::Vector2 *result = 0 ;
4382
4383   arg1 = (Dali::Vector2 *)jarg1;
4384   arg2 = (Dali::Vector2 *)jarg2;
4385   if (!arg2) {
4386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4387     return 0;
4388   }
4389   {
4390     try {
4391       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4392     } catch (std::out_of_range& e) {
4393       {
4394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4395       };
4396     } catch (std::exception& e) {
4397       {
4398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4399       };
4400     } catch (...) {
4401       {
4402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4403       };
4404     }
4405   }
4406   jresult = (void *)result;
4407   return jresult;
4408 }
4409
4410
4411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4412   void * jresult ;
4413   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4414   float arg2 ;
4415   Dali::Vector2 *result = 0 ;
4416
4417   arg1 = (Dali::Vector2 *)jarg1;
4418   arg2 = (float)jarg2;
4419   {
4420     try {
4421       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4422     } catch (std::out_of_range& e) {
4423       {
4424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4425       };
4426     } catch (std::exception& e) {
4427       {
4428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4429       };
4430     } catch (...) {
4431       {
4432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4433       };
4434     }
4435   }
4436   jresult = (void *)result;
4437   return jresult;
4438 }
4439
4440
4441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4442   void * jresult ;
4443   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4444   Dali::Vector2 *arg2 = 0 ;
4445   Dali::Vector2 result;
4446
4447   arg1 = (Dali::Vector2 *)jarg1;
4448   arg2 = (Dali::Vector2 *)jarg2;
4449   if (!arg2) {
4450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4451     return 0;
4452   }
4453   {
4454     try {
4455       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4456     } catch (std::out_of_range& e) {
4457       {
4458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4459       };
4460     } catch (std::exception& e) {
4461       {
4462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4463       };
4464     } catch (...) {
4465       {
4466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4467       };
4468     }
4469   }
4470   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4471   return jresult;
4472 }
4473
4474
4475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4476   void * jresult ;
4477   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4478   float arg2 ;
4479   Dali::Vector2 result;
4480
4481   arg1 = (Dali::Vector2 *)jarg1;
4482   arg2 = (float)jarg2;
4483   {
4484     try {
4485       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4486     } catch (std::out_of_range& e) {
4487       {
4488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4489       };
4490     } catch (std::exception& e) {
4491       {
4492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4493       };
4494     } catch (...) {
4495       {
4496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4497       };
4498     }
4499   }
4500   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4501   return jresult;
4502 }
4503
4504
4505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4506   void * jresult ;
4507   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4508   Dali::Vector2 *arg2 = 0 ;
4509   Dali::Vector2 *result = 0 ;
4510
4511   arg1 = (Dali::Vector2 *)jarg1;
4512   arg2 = (Dali::Vector2 *)jarg2;
4513   if (!arg2) {
4514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4515     return 0;
4516   }
4517   {
4518     try {
4519       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4520     } catch (std::out_of_range& e) {
4521       {
4522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4523       };
4524     } catch (std::exception& e) {
4525       {
4526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4527       };
4528     } catch (...) {
4529       {
4530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4531       };
4532     }
4533   }
4534   jresult = (void *)result;
4535   return jresult;
4536 }
4537
4538
4539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4540   void * jresult ;
4541   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4542   float arg2 ;
4543   Dali::Vector2 *result = 0 ;
4544
4545   arg1 = (Dali::Vector2 *)jarg1;
4546   arg2 = (float)jarg2;
4547   {
4548     try {
4549       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4550     } catch (std::out_of_range& e) {
4551       {
4552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4553       };
4554     } catch (std::exception& e) {
4555       {
4556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4557       };
4558     } catch (...) {
4559       {
4560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4561       };
4562     }
4563   }
4564   jresult = (void *)result;
4565   return jresult;
4566 }
4567
4568
4569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4570   void * jresult ;
4571   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4572   Dali::Vector2 result;
4573
4574   arg1 = (Dali::Vector2 *)jarg1;
4575   {
4576     try {
4577       result = ((Dali::Vector2 const *)arg1)->operator -();
4578     } catch (std::out_of_range& e) {
4579       {
4580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4581       };
4582     } catch (std::exception& e) {
4583       {
4584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4585       };
4586     } catch (...) {
4587       {
4588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4589       };
4590     }
4591   }
4592   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4593   return jresult;
4594 }
4595
4596
4597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
4598   unsigned int jresult ;
4599   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4600   Dali::Vector2 *arg2 = 0 ;
4601   bool result;
4602
4603   arg1 = (Dali::Vector2 *)jarg1;
4604   arg2 = (Dali::Vector2 *)jarg2;
4605   if (!arg2) {
4606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4607     return 0;
4608   }
4609   {
4610     try {
4611       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
4612     } catch (std::out_of_range& e) {
4613       {
4614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4615       };
4616     } catch (std::exception& e) {
4617       {
4618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4619       };
4620     } catch (...) {
4621       {
4622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4623       };
4624     }
4625   }
4626   jresult = result;
4627   return jresult;
4628 }
4629
4630
4631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
4632   unsigned int jresult ;
4633   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4634   Dali::Vector2 *arg2 = 0 ;
4635   bool result;
4636
4637   arg1 = (Dali::Vector2 *)jarg1;
4638   arg2 = (Dali::Vector2 *)jarg2;
4639   if (!arg2) {
4640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4641     return 0;
4642   }
4643   {
4644     try {
4645       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
4646     } catch (std::out_of_range& e) {
4647       {
4648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4649       };
4650     } catch (std::exception& e) {
4651       {
4652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4653       };
4654     } catch (...) {
4655       {
4656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4657       };
4658     }
4659   }
4660   jresult = result;
4661   return jresult;
4662 }
4663
4664
4665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
4666   float jresult ;
4667   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4668   unsigned int arg2 ;
4669   float *result = 0 ;
4670
4671   arg1 = (Dali::Vector2 *)jarg1;
4672   arg2 = (unsigned int)jarg2;
4673   {
4674     try {
4675       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
4676     } catch (std::out_of_range& e) {
4677       {
4678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4679       };
4680     } catch (std::exception& e) {
4681       {
4682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4683       };
4684     } catch (...) {
4685       {
4686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4687       };
4688     }
4689   }
4690   jresult = *result;
4691   return jresult;
4692 }
4693
4694
4695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
4696   float jresult ;
4697   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4698   float result;
4699
4700   arg1 = (Dali::Vector2 *)jarg1;
4701   {
4702     try {
4703       result = (float)((Dali::Vector2 const *)arg1)->Length();
4704     } catch (std::out_of_range& e) {
4705       {
4706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4707       };
4708     } catch (std::exception& e) {
4709       {
4710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4711       };
4712     } catch (...) {
4713       {
4714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4715       };
4716     }
4717   }
4718   jresult = result;
4719   return jresult;
4720 }
4721
4722
4723 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
4724   float jresult ;
4725   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4726   float result;
4727
4728   arg1 = (Dali::Vector2 *)jarg1;
4729   {
4730     try {
4731       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
4732     } catch (std::out_of_range& e) {
4733       {
4734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4735       };
4736     } catch (std::exception& e) {
4737       {
4738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4739       };
4740     } catch (...) {
4741       {
4742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4743       };
4744     }
4745   }
4746   jresult = result;
4747   return jresult;
4748 }
4749
4750
4751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
4752   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4753
4754   arg1 = (Dali::Vector2 *)jarg1;
4755   {
4756     try {
4757       (arg1)->Normalize();
4758     } catch (std::out_of_range& e) {
4759       {
4760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4761       };
4762     } catch (std::exception& e) {
4763       {
4764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4765       };
4766     } catch (...) {
4767       {
4768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4769       };
4770     }
4771   }
4772 }
4773
4774
4775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
4776   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4777   Dali::Vector2 *arg2 = 0 ;
4778   Dali::Vector2 *arg3 = 0 ;
4779
4780   arg1 = (Dali::Vector2 *)jarg1;
4781   arg2 = (Dali::Vector2 *)jarg2;
4782   if (!arg2) {
4783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4784     return ;
4785   }
4786   arg3 = (Dali::Vector2 *)jarg3;
4787   if (!arg3) {
4788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4789     return ;
4790   }
4791   {
4792     try {
4793       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
4794     } catch (std::out_of_range& e) {
4795       {
4796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4797       };
4798     } catch (std::exception& e) {
4799       {
4800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4801       };
4802     } catch (...) {
4803       {
4804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4805       };
4806     }
4807   }
4808 }
4809
4810
4811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
4812   void * jresult ;
4813   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4814   float *result = 0 ;
4815
4816   arg1 = (Dali::Vector2 *)jarg1;
4817   {
4818     try {
4819       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
4820     } catch (std::out_of_range& e) {
4821       {
4822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4823       };
4824     } catch (std::exception& e) {
4825       {
4826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4827       };
4828     } catch (...) {
4829       {
4830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4831       };
4832     }
4833   }
4834   jresult = (void *)result;
4835   return jresult;
4836 }
4837
4838
4839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
4840   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4841   float arg2 ;
4842
4843   arg1 = (Dali::Vector2 *)jarg1;
4844   arg2 = (float)jarg2;
4845   if (arg1) (arg1)->x = arg2;
4846 }
4847
4848
4849 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
4850   float jresult ;
4851   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4852   float result;
4853
4854   arg1 = (Dali::Vector2 *)jarg1;
4855   result = (float) ((arg1)->x);
4856   jresult = result;
4857   return jresult;
4858 }
4859
4860
4861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
4862   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4863   float arg2 ;
4864
4865   arg1 = (Dali::Vector2 *)jarg1;
4866   arg2 = (float)jarg2;
4867   if (arg1) (arg1)->width = arg2;
4868 }
4869
4870
4871 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
4872   float jresult ;
4873   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4874   float result;
4875
4876   arg1 = (Dali::Vector2 *)jarg1;
4877   result = (float) ((arg1)->width);
4878   jresult = result;
4879   return jresult;
4880 }
4881
4882
4883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
4884   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4885   float arg2 ;
4886
4887   arg1 = (Dali::Vector2 *)jarg1;
4888   arg2 = (float)jarg2;
4889   if (arg1) (arg1)->y = arg2;
4890 }
4891
4892
4893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
4894   float jresult ;
4895   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4896   float result;
4897
4898   arg1 = (Dali::Vector2 *)jarg1;
4899   result = (float) ((arg1)->y);
4900   jresult = result;
4901   return jresult;
4902 }
4903
4904
4905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
4906   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4907   float arg2 ;
4908
4909   arg1 = (Dali::Vector2 *)jarg1;
4910   arg2 = (float)jarg2;
4911   if (arg1) (arg1)->height = arg2;
4912 }
4913
4914
4915 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
4916   float jresult ;
4917   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4918   float result;
4919
4920   arg1 = (Dali::Vector2 *)jarg1;
4921   result = (float) ((arg1)->height);
4922   jresult = result;
4923   return jresult;
4924 }
4925
4926
4927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
4928   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4929
4930   arg1 = (Dali::Vector2 *)jarg1;
4931   {
4932     try {
4933       delete arg1;
4934     } catch (std::out_of_range& e) {
4935       {
4936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4937       };
4938     } catch (std::exception& e) {
4939       {
4940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4941       };
4942     } catch (...) {
4943       {
4944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4945       };
4946     }
4947   }
4948 }
4949
4950
4951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
4952   void * jresult ;
4953   Dali::Vector2 *arg1 = 0 ;
4954   Dali::Vector2 *arg2 = 0 ;
4955   Dali::Vector2 result;
4956
4957   arg1 = (Dali::Vector2 *)jarg1;
4958   if (!arg1) {
4959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4960     return 0;
4961   }
4962   arg2 = (Dali::Vector2 *)jarg2;
4963   if (!arg2) {
4964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4965     return 0;
4966   }
4967   {
4968     try {
4969       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
4970     } catch (std::out_of_range& e) {
4971       {
4972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4973       };
4974     } catch (std::exception& e) {
4975       {
4976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4977       };
4978     } catch (...) {
4979       {
4980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4981       };
4982     }
4983   }
4984   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4985   return jresult;
4986 }
4987
4988
4989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
4990   void * jresult ;
4991   Dali::Vector2 *arg1 = 0 ;
4992   Dali::Vector2 *arg2 = 0 ;
4993   Dali::Vector2 result;
4994
4995   arg1 = (Dali::Vector2 *)jarg1;
4996   if (!arg1) {
4997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4998     return 0;
4999   }
5000   arg2 = (Dali::Vector2 *)jarg2;
5001   if (!arg2) {
5002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5003     return 0;
5004   }
5005   {
5006     try {
5007       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5008     } catch (std::out_of_range& e) {
5009       {
5010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5011       };
5012     } catch (std::exception& e) {
5013       {
5014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5015       };
5016     } catch (...) {
5017       {
5018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5019       };
5020     }
5021   }
5022   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5023   return jresult;
5024 }
5025
5026
5027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5028   void * jresult ;
5029   Dali::Vector2 *arg1 = 0 ;
5030   float *arg2 = 0 ;
5031   float *arg3 = 0 ;
5032   float temp2 ;
5033   float temp3 ;
5034   Dali::Vector2 result;
5035
5036   arg1 = (Dali::Vector2 *)jarg1;
5037   if (!arg1) {
5038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5039     return 0;
5040   }
5041   temp2 = (float)jarg2;
5042   arg2 = &temp2;
5043   temp3 = (float)jarg3;
5044   arg3 = &temp3;
5045   {
5046     try {
5047       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5048     } catch (std::out_of_range& e) {
5049       {
5050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5051       };
5052     } catch (std::exception& e) {
5053       {
5054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5055       };
5056     } catch (...) {
5057       {
5058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5059       };
5060     }
5061   }
5062   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5063   return jresult;
5064 }
5065
5066
5067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5068   void * jresult ;
5069   Dali::Vector3 *result = 0 ;
5070
5071   {
5072     try {
5073       result = (Dali::Vector3 *)new Dali::Vector3();
5074     } catch (std::out_of_range& e) {
5075       {
5076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5077       };
5078     } catch (std::exception& e) {
5079       {
5080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5081       };
5082     } catch (...) {
5083       {
5084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5085       };
5086     }
5087   }
5088   jresult = (void *)result;
5089   return jresult;
5090 }
5091
5092
5093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5094   void * jresult ;
5095   float arg1 ;
5096   float arg2 ;
5097   float arg3 ;
5098   Dali::Vector3 *result = 0 ;
5099
5100   arg1 = (float)jarg1;
5101   arg2 = (float)jarg2;
5102   arg3 = (float)jarg3;
5103   {
5104     try {
5105       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5106     } catch (std::out_of_range& e) {
5107       {
5108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5109       };
5110     } catch (std::exception& e) {
5111       {
5112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5113       };
5114     } catch (...) {
5115       {
5116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5117       };
5118     }
5119   }
5120   jresult = (void *)result;
5121   return jresult;
5122 }
5123
5124
5125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5126   void * jresult ;
5127   float *arg1 = (float *) 0 ;
5128   Dali::Vector3 *result = 0 ;
5129
5130   arg1 = jarg1;
5131   {
5132     try {
5133       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5134     } catch (std::out_of_range& e) {
5135       {
5136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5137       };
5138     } catch (std::exception& e) {
5139       {
5140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5141       };
5142     } catch (...) {
5143       {
5144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5145       };
5146     }
5147   }
5148   jresult = (void *)result;
5149
5150
5151   return jresult;
5152 }
5153
5154
5155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5156   void * jresult ;
5157   Dali::Vector2 *arg1 = 0 ;
5158   Dali::Vector3 *result = 0 ;
5159
5160   arg1 = (Dali::Vector2 *)jarg1;
5161   if (!arg1) {
5162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5163     return 0;
5164   }
5165   {
5166     try {
5167       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5168     } catch (std::out_of_range& e) {
5169       {
5170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5171       };
5172     } catch (std::exception& e) {
5173       {
5174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5175       };
5176     } catch (...) {
5177       {
5178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5179       };
5180     }
5181   }
5182   jresult = (void *)result;
5183   return jresult;
5184 }
5185
5186
5187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5188   void * jresult ;
5189   Dali::Vector4 *arg1 = 0 ;
5190   Dali::Vector3 *result = 0 ;
5191
5192   arg1 = (Dali::Vector4 *)jarg1;
5193   if (!arg1) {
5194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5195     return 0;
5196   }
5197   {
5198     try {
5199       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5200     } catch (std::out_of_range& e) {
5201       {
5202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5203       };
5204     } catch (std::exception& e) {
5205       {
5206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5207       };
5208     } catch (...) {
5209       {
5210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5211       };
5212     }
5213   }
5214   jresult = (void *)result;
5215   return jresult;
5216 }
5217
5218
5219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5220   void * jresult ;
5221   Dali::Vector3 *result = 0 ;
5222
5223   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5224   jresult = (void *)result;
5225   return jresult;
5226 }
5227
5228
5229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5230   void * jresult ;
5231   Dali::Vector3 *result = 0 ;
5232
5233   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5234   jresult = (void *)result;
5235   return jresult;
5236 }
5237
5238
5239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5240   void * jresult ;
5241   Dali::Vector3 *result = 0 ;
5242
5243   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5244   jresult = (void *)result;
5245   return jresult;
5246 }
5247
5248
5249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5250   void * jresult ;
5251   Dali::Vector3 *result = 0 ;
5252
5253   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5254   jresult = (void *)result;
5255   return jresult;
5256 }
5257
5258
5259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5260   void * jresult ;
5261   Dali::Vector3 *result = 0 ;
5262
5263   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5264   jresult = (void *)result;
5265   return jresult;
5266 }
5267
5268
5269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5270   void * jresult ;
5271   Dali::Vector3 *result = 0 ;
5272
5273   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5274   jresult = (void *)result;
5275   return jresult;
5276 }
5277
5278
5279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5280   void * jresult ;
5281   Dali::Vector3 *result = 0 ;
5282
5283   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5284   jresult = (void *)result;
5285   return jresult;
5286 }
5287
5288
5289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5290   void * jresult ;
5291   Dali::Vector3 *result = 0 ;
5292
5293   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5294   jresult = (void *)result;
5295   return jresult;
5296 }
5297
5298
5299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5300   void * jresult ;
5301   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5302   float *arg2 = (float *) 0 ;
5303   Dali::Vector3 *result = 0 ;
5304
5305   arg1 = (Dali::Vector3 *)jarg1;
5306   arg2 = jarg2;
5307   {
5308     try {
5309       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5310     } catch (std::out_of_range& e) {
5311       {
5312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5313       };
5314     } catch (std::exception& e) {
5315       {
5316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5317       };
5318     } catch (...) {
5319       {
5320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5321       };
5322     }
5323   }
5324   jresult = (void *)result;
5325
5326
5327   return jresult;
5328 }
5329
5330
5331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5332   void * jresult ;
5333   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5334   Dali::Vector2 *arg2 = 0 ;
5335   Dali::Vector3 *result = 0 ;
5336
5337   arg1 = (Dali::Vector3 *)jarg1;
5338   arg2 = (Dali::Vector2 *)jarg2;
5339   if (!arg2) {
5340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5341     return 0;
5342   }
5343   {
5344     try {
5345       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5346     } catch (std::out_of_range& e) {
5347       {
5348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5349       };
5350     } catch (std::exception& e) {
5351       {
5352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5353       };
5354     } catch (...) {
5355       {
5356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5357       };
5358     }
5359   }
5360   jresult = (void *)result;
5361   return jresult;
5362 }
5363
5364
5365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5366   void * jresult ;
5367   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5368   Dali::Vector4 *arg2 = 0 ;
5369   Dali::Vector3 *result = 0 ;
5370
5371   arg1 = (Dali::Vector3 *)jarg1;
5372   arg2 = (Dali::Vector4 *)jarg2;
5373   if (!arg2) {
5374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5375     return 0;
5376   }
5377   {
5378     try {
5379       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5380     } catch (std::out_of_range& e) {
5381       {
5382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5383       };
5384     } catch (std::exception& e) {
5385       {
5386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5387       };
5388     } catch (...) {
5389       {
5390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5391       };
5392     }
5393   }
5394   jresult = (void *)result;
5395   return jresult;
5396 }
5397
5398
5399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5400   void * jresult ;
5401   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5402   Dali::Vector3 *arg2 = 0 ;
5403   Dali::Vector3 result;
5404
5405   arg1 = (Dali::Vector3 *)jarg1;
5406   arg2 = (Dali::Vector3 *)jarg2;
5407   if (!arg2) {
5408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5409     return 0;
5410   }
5411   {
5412     try {
5413       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5414     } catch (std::out_of_range& e) {
5415       {
5416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5417       };
5418     } catch (std::exception& e) {
5419       {
5420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5421       };
5422     } catch (...) {
5423       {
5424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5425       };
5426     }
5427   }
5428   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5429   return jresult;
5430 }
5431
5432
5433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5434   void * jresult ;
5435   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5436   Dali::Vector3 *arg2 = 0 ;
5437   Dali::Vector3 *result = 0 ;
5438
5439   arg1 = (Dali::Vector3 *)jarg1;
5440   arg2 = (Dali::Vector3 *)jarg2;
5441   if (!arg2) {
5442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5443     return 0;
5444   }
5445   {
5446     try {
5447       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5448     } catch (std::out_of_range& e) {
5449       {
5450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5451       };
5452     } catch (std::exception& e) {
5453       {
5454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5455       };
5456     } catch (...) {
5457       {
5458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5459       };
5460     }
5461   }
5462   jresult = (void *)result;
5463   return jresult;
5464 }
5465
5466
5467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5468   void * jresult ;
5469   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5470   Dali::Vector3 *arg2 = 0 ;
5471   Dali::Vector3 result;
5472
5473   arg1 = (Dali::Vector3 *)jarg1;
5474   arg2 = (Dali::Vector3 *)jarg2;
5475   if (!arg2) {
5476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5477     return 0;
5478   }
5479   {
5480     try {
5481       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
5482     } catch (std::out_of_range& e) {
5483       {
5484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5485       };
5486     } catch (std::exception& e) {
5487       {
5488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5489       };
5490     } catch (...) {
5491       {
5492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5493       };
5494     }
5495   }
5496   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5497   return jresult;
5498 }
5499
5500
5501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
5502   void * jresult ;
5503   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5504   Dali::Vector3 *arg2 = 0 ;
5505   Dali::Vector3 *result = 0 ;
5506
5507   arg1 = (Dali::Vector3 *)jarg1;
5508   arg2 = (Dali::Vector3 *)jarg2;
5509   if (!arg2) {
5510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5511     return 0;
5512   }
5513   {
5514     try {
5515       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
5516     } catch (std::out_of_range& e) {
5517       {
5518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5519       };
5520     } catch (std::exception& e) {
5521       {
5522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5523       };
5524     } catch (...) {
5525       {
5526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5527       };
5528     }
5529   }
5530   jresult = (void *)result;
5531   return jresult;
5532 }
5533
5534
5535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
5536   void * jresult ;
5537   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5538   Dali::Vector3 *arg2 = 0 ;
5539   Dali::Vector3 result;
5540
5541   arg1 = (Dali::Vector3 *)jarg1;
5542   arg2 = (Dali::Vector3 *)jarg2;
5543   if (!arg2) {
5544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5545     return 0;
5546   }
5547   {
5548     try {
5549       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
5550     } catch (std::out_of_range& e) {
5551       {
5552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5553       };
5554     } catch (std::exception& e) {
5555       {
5556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5557       };
5558     } catch (...) {
5559       {
5560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5561       };
5562     }
5563   }
5564   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5565   return jresult;
5566 }
5567
5568
5569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
5570   void * jresult ;
5571   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5572   float arg2 ;
5573   Dali::Vector3 result;
5574
5575   arg1 = (Dali::Vector3 *)jarg1;
5576   arg2 = (float)jarg2;
5577   {
5578     try {
5579       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
5580     } catch (std::out_of_range& e) {
5581       {
5582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5583       };
5584     } catch (std::exception& e) {
5585       {
5586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5587       };
5588     } catch (...) {
5589       {
5590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5591       };
5592     }
5593   }
5594   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5595   return jresult;
5596 }
5597
5598
5599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
5600   void * jresult ;
5601   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5602   Dali::Vector3 *arg2 = 0 ;
5603   Dali::Vector3 *result = 0 ;
5604
5605   arg1 = (Dali::Vector3 *)jarg1;
5606   arg2 = (Dali::Vector3 *)jarg2;
5607   if (!arg2) {
5608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5609     return 0;
5610   }
5611   {
5612     try {
5613       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
5614     } catch (std::out_of_range& e) {
5615       {
5616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5617       };
5618     } catch (std::exception& e) {
5619       {
5620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5621       };
5622     } catch (...) {
5623       {
5624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5625       };
5626     }
5627   }
5628   jresult = (void *)result;
5629   return jresult;
5630 }
5631
5632
5633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
5634   void * jresult ;
5635   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5636   float arg2 ;
5637   Dali::Vector3 *result = 0 ;
5638
5639   arg1 = (Dali::Vector3 *)jarg1;
5640   arg2 = (float)jarg2;
5641   {
5642     try {
5643       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
5644     } catch (std::out_of_range& e) {
5645       {
5646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5647       };
5648     } catch (std::exception& e) {
5649       {
5650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5651       };
5652     } catch (...) {
5653       {
5654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5655       };
5656     }
5657   }
5658   jresult = (void *)result;
5659   return jresult;
5660 }
5661
5662
5663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
5664   void * jresult ;
5665   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5666   Dali::Quaternion *arg2 = 0 ;
5667   Dali::Vector3 *result = 0 ;
5668
5669   arg1 = (Dali::Vector3 *)jarg1;
5670   arg2 = (Dali::Quaternion *)jarg2;
5671   if (!arg2) {
5672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
5673     return 0;
5674   }
5675   {
5676     try {
5677       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
5678     } catch (std::out_of_range& e) {
5679       {
5680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5681       };
5682     } catch (std::exception& e) {
5683       {
5684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5685       };
5686     } catch (...) {
5687       {
5688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5689       };
5690     }
5691   }
5692   jresult = (void *)result;
5693   return jresult;
5694 }
5695
5696
5697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
5698   void * jresult ;
5699   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5700   Dali::Vector3 *arg2 = 0 ;
5701   Dali::Vector3 result;
5702
5703   arg1 = (Dali::Vector3 *)jarg1;
5704   arg2 = (Dali::Vector3 *)jarg2;
5705   if (!arg2) {
5706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5707     return 0;
5708   }
5709   {
5710     try {
5711       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
5712     } catch (std::out_of_range& e) {
5713       {
5714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5715       };
5716     } catch (std::exception& e) {
5717       {
5718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5719       };
5720     } catch (...) {
5721       {
5722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5723       };
5724     }
5725   }
5726   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5727   return jresult;
5728 }
5729
5730
5731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
5732   void * jresult ;
5733   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5734   float arg2 ;
5735   Dali::Vector3 result;
5736
5737   arg1 = (Dali::Vector3 *)jarg1;
5738   arg2 = (float)jarg2;
5739   {
5740     try {
5741       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
5742     } catch (std::out_of_range& e) {
5743       {
5744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5745       };
5746     } catch (std::exception& e) {
5747       {
5748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5749       };
5750     } catch (...) {
5751       {
5752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5753       };
5754     }
5755   }
5756   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5757   return jresult;
5758 }
5759
5760
5761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
5762   void * jresult ;
5763   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5764   Dali::Vector3 *arg2 = 0 ;
5765   Dali::Vector3 *result = 0 ;
5766
5767   arg1 = (Dali::Vector3 *)jarg1;
5768   arg2 = (Dali::Vector3 *)jarg2;
5769   if (!arg2) {
5770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5771     return 0;
5772   }
5773   {
5774     try {
5775       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
5776     } catch (std::out_of_range& e) {
5777       {
5778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5779       };
5780     } catch (std::exception& e) {
5781       {
5782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5783       };
5784     } catch (...) {
5785       {
5786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5787       };
5788     }
5789   }
5790   jresult = (void *)result;
5791   return jresult;
5792 }
5793
5794
5795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
5796   void * jresult ;
5797   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5798   float arg2 ;
5799   Dali::Vector3 *result = 0 ;
5800
5801   arg1 = (Dali::Vector3 *)jarg1;
5802   arg2 = (float)jarg2;
5803   {
5804     try {
5805       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
5806     } catch (std::out_of_range& e) {
5807       {
5808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5809       };
5810     } catch (std::exception& e) {
5811       {
5812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5813       };
5814     } catch (...) {
5815       {
5816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5817       };
5818     }
5819   }
5820   jresult = (void *)result;
5821   return jresult;
5822 }
5823
5824
5825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
5826   void * jresult ;
5827   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5828   Dali::Vector3 result;
5829
5830   arg1 = (Dali::Vector3 *)jarg1;
5831   {
5832     try {
5833       result = ((Dali::Vector3 const *)arg1)->operator -();
5834     } catch (std::out_of_range& e) {
5835       {
5836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5837       };
5838     } catch (std::exception& e) {
5839       {
5840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5841       };
5842     } catch (...) {
5843       {
5844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5845       };
5846     }
5847   }
5848   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5849   return jresult;
5850 }
5851
5852
5853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
5854   unsigned int jresult ;
5855   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5856   Dali::Vector3 *arg2 = 0 ;
5857   bool result;
5858
5859   arg1 = (Dali::Vector3 *)jarg1;
5860   arg2 = (Dali::Vector3 *)jarg2;
5861   if (!arg2) {
5862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5863     return 0;
5864   }
5865   {
5866     try {
5867       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
5868     } catch (std::out_of_range& e) {
5869       {
5870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5871       };
5872     } catch (std::exception& e) {
5873       {
5874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5875       };
5876     } catch (...) {
5877       {
5878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5879       };
5880     }
5881   }
5882   jresult = result;
5883   return jresult;
5884 }
5885
5886
5887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
5888   unsigned int jresult ;
5889   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5890   Dali::Vector3 *arg2 = 0 ;
5891   bool result;
5892
5893   arg1 = (Dali::Vector3 *)jarg1;
5894   arg2 = (Dali::Vector3 *)jarg2;
5895   if (!arg2) {
5896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5897     return 0;
5898   }
5899   {
5900     try {
5901       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
5902     } catch (std::out_of_range& e) {
5903       {
5904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5905       };
5906     } catch (std::exception& e) {
5907       {
5908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5909       };
5910     } catch (...) {
5911       {
5912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5913       };
5914     }
5915   }
5916   jresult = result;
5917   return jresult;
5918 }
5919
5920
5921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5922   float jresult ;
5923   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5924   unsigned int arg2 ;
5925   float *result = 0 ;
5926
5927   arg1 = (Dali::Vector3 *)jarg1;
5928   arg2 = (unsigned int)jarg2;
5929   {
5930     try {
5931       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
5932     } catch (std::out_of_range& e) {
5933       {
5934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5935       };
5936     } catch (std::exception& e) {
5937       {
5938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5939       };
5940     } catch (...) {
5941       {
5942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5943       };
5944     }
5945   }
5946   jresult = *result;
5947   return jresult;
5948 }
5949
5950
5951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
5952   float jresult ;
5953   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5954   Dali::Vector3 *arg2 = 0 ;
5955   float result;
5956
5957   arg1 = (Dali::Vector3 *)jarg1;
5958   arg2 = (Dali::Vector3 *)jarg2;
5959   if (!arg2) {
5960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5961     return 0;
5962   }
5963   {
5964     try {
5965       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
5966     } catch (std::out_of_range& e) {
5967       {
5968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5969       };
5970     } catch (std::exception& e) {
5971       {
5972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5973       };
5974     } catch (...) {
5975       {
5976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5977       };
5978     }
5979   }
5980   jresult = result;
5981   return jresult;
5982 }
5983
5984
5985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
5986   void * jresult ;
5987   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5988   Dali::Vector3 *arg2 = 0 ;
5989   Dali::Vector3 result;
5990
5991   arg1 = (Dali::Vector3 *)jarg1;
5992   arg2 = (Dali::Vector3 *)jarg2;
5993   if (!arg2) {
5994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5995     return 0;
5996   }
5997   {
5998     try {
5999       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6000     } catch (std::out_of_range& e) {
6001       {
6002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6003       };
6004     } catch (std::exception& e) {
6005       {
6006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6007       };
6008     } catch (...) {
6009       {
6010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6011       };
6012     }
6013   }
6014   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6015   return jresult;
6016 }
6017
6018
6019 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6020   float jresult ;
6021   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6022   float result;
6023
6024   arg1 = (Dali::Vector3 *)jarg1;
6025   {
6026     try {
6027       result = (float)((Dali::Vector3 const *)arg1)->Length();
6028     } catch (std::out_of_range& e) {
6029       {
6030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6031       };
6032     } catch (std::exception& e) {
6033       {
6034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6035       };
6036     } catch (...) {
6037       {
6038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6039       };
6040     }
6041   }
6042   jresult = result;
6043   return jresult;
6044 }
6045
6046
6047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6048   float jresult ;
6049   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6050   float result;
6051
6052   arg1 = (Dali::Vector3 *)jarg1;
6053   {
6054     try {
6055       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6056     } catch (std::out_of_range& e) {
6057       {
6058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6059       };
6060     } catch (std::exception& e) {
6061       {
6062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6063       };
6064     } catch (...) {
6065       {
6066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6067       };
6068     }
6069   }
6070   jresult = result;
6071   return jresult;
6072 }
6073
6074
6075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6076   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6077
6078   arg1 = (Dali::Vector3 *)jarg1;
6079   {
6080     try {
6081       (arg1)->Normalize();
6082     } catch (std::out_of_range& e) {
6083       {
6084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6085       };
6086     } catch (std::exception& e) {
6087       {
6088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6089       };
6090     } catch (...) {
6091       {
6092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6093       };
6094     }
6095   }
6096 }
6097
6098
6099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6100   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6101   Dali::Vector3 *arg2 = 0 ;
6102   Dali::Vector3 *arg3 = 0 ;
6103
6104   arg1 = (Dali::Vector3 *)jarg1;
6105   arg2 = (Dali::Vector3 *)jarg2;
6106   if (!arg2) {
6107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6108     return ;
6109   }
6110   arg3 = (Dali::Vector3 *)jarg3;
6111   if (!arg3) {
6112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6113     return ;
6114   }
6115   {
6116     try {
6117       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6118     } catch (std::out_of_range& e) {
6119       {
6120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6121       };
6122     } catch (std::exception& e) {
6123       {
6124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6125       };
6126     } catch (...) {
6127       {
6128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6129       };
6130     }
6131   }
6132 }
6133
6134
6135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6136   void * jresult ;
6137   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6138   float *result = 0 ;
6139
6140   arg1 = (Dali::Vector3 *)jarg1;
6141   {
6142     try {
6143       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6144     } catch (std::out_of_range& e) {
6145       {
6146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6147       };
6148     } catch (std::exception& e) {
6149       {
6150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6151       };
6152     } catch (...) {
6153       {
6154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6155       };
6156     }
6157   }
6158   jresult = (void *)result;
6159   return jresult;
6160 }
6161
6162
6163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6164   void * jresult ;
6165   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6166   Dali::Vector2 *result = 0 ;
6167
6168   arg1 = (Dali::Vector3 *)jarg1;
6169   {
6170     try {
6171       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6172     } catch (std::out_of_range& e) {
6173       {
6174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6175       };
6176     } catch (std::exception& e) {
6177       {
6178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6179       };
6180     } catch (...) {
6181       {
6182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6183       };
6184     }
6185   }
6186   jresult = (void *)result;
6187   return jresult;
6188 }
6189
6190
6191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6192   void * jresult ;
6193   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6194   Dali::Vector2 *result = 0 ;
6195
6196   arg1 = (Dali::Vector3 *)jarg1;
6197   {
6198     try {
6199       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6200     } catch (std::out_of_range& e) {
6201       {
6202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6203       };
6204     } catch (std::exception& e) {
6205       {
6206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6207       };
6208     } catch (...) {
6209       {
6210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6211       };
6212     }
6213   }
6214   jresult = (void *)result;
6215   return jresult;
6216 }
6217
6218
6219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6220   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6221   float arg2 ;
6222
6223   arg1 = (Dali::Vector3 *)jarg1;
6224   arg2 = (float)jarg2;
6225   if (arg1) (arg1)->x = arg2;
6226 }
6227
6228
6229 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6230   float jresult ;
6231   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6232   float result;
6233
6234   arg1 = (Dali::Vector3 *)jarg1;
6235   result = (float) ((arg1)->x);
6236   jresult = result;
6237   return jresult;
6238 }
6239
6240
6241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6242   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6243   float arg2 ;
6244
6245   arg1 = (Dali::Vector3 *)jarg1;
6246   arg2 = (float)jarg2;
6247   if (arg1) (arg1)->width = arg2;
6248 }
6249
6250
6251 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6252   float jresult ;
6253   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6254   float result;
6255
6256   arg1 = (Dali::Vector3 *)jarg1;
6257   result = (float) ((arg1)->width);
6258   jresult = result;
6259   return jresult;
6260 }
6261
6262
6263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6264   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6265   float arg2 ;
6266
6267   arg1 = (Dali::Vector3 *)jarg1;
6268   arg2 = (float)jarg2;
6269   if (arg1) (arg1)->r = arg2;
6270 }
6271
6272
6273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6274   float jresult ;
6275   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6276   float result;
6277
6278   arg1 = (Dali::Vector3 *)jarg1;
6279   result = (float) ((arg1)->r);
6280   jresult = result;
6281   return jresult;
6282 }
6283
6284
6285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6286   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6287   float arg2 ;
6288
6289   arg1 = (Dali::Vector3 *)jarg1;
6290   arg2 = (float)jarg2;
6291   if (arg1) (arg1)->y = arg2;
6292 }
6293
6294
6295 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6296   float jresult ;
6297   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6298   float result;
6299
6300   arg1 = (Dali::Vector3 *)jarg1;
6301   result = (float) ((arg1)->y);
6302   jresult = result;
6303   return jresult;
6304 }
6305
6306
6307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6308   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6309   float arg2 ;
6310
6311   arg1 = (Dali::Vector3 *)jarg1;
6312   arg2 = (float)jarg2;
6313   if (arg1) (arg1)->height = arg2;
6314 }
6315
6316
6317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6318   float jresult ;
6319   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6320   float result;
6321
6322   arg1 = (Dali::Vector3 *)jarg1;
6323   result = (float) ((arg1)->height);
6324   jresult = result;
6325   return jresult;
6326 }
6327
6328
6329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6330   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6331   float arg2 ;
6332
6333   arg1 = (Dali::Vector3 *)jarg1;
6334   arg2 = (float)jarg2;
6335   if (arg1) (arg1)->g = arg2;
6336 }
6337
6338
6339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6340   float jresult ;
6341   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6342   float result;
6343
6344   arg1 = (Dali::Vector3 *)jarg1;
6345   result = (float) ((arg1)->g);
6346   jresult = result;
6347   return jresult;
6348 }
6349
6350
6351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6352   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6353   float arg2 ;
6354
6355   arg1 = (Dali::Vector3 *)jarg1;
6356   arg2 = (float)jarg2;
6357   if (arg1) (arg1)->z = arg2;
6358 }
6359
6360
6361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
6362   float jresult ;
6363   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6364   float result;
6365
6366   arg1 = (Dali::Vector3 *)jarg1;
6367   result = (float) ((arg1)->z);
6368   jresult = result;
6369   return jresult;
6370 }
6371
6372
6373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
6374   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6375   float arg2 ;
6376
6377   arg1 = (Dali::Vector3 *)jarg1;
6378   arg2 = (float)jarg2;
6379   if (arg1) (arg1)->depth = arg2;
6380 }
6381
6382
6383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
6384   float jresult ;
6385   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6386   float result;
6387
6388   arg1 = (Dali::Vector3 *)jarg1;
6389   result = (float) ((arg1)->depth);
6390   jresult = result;
6391   return jresult;
6392 }
6393
6394
6395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
6396   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6397   float arg2 ;
6398
6399   arg1 = (Dali::Vector3 *)jarg1;
6400   arg2 = (float)jarg2;
6401   if (arg1) (arg1)->b = arg2;
6402 }
6403
6404
6405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
6406   float jresult ;
6407   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6408   float result;
6409
6410   arg1 = (Dali::Vector3 *)jarg1;
6411   result = (float) ((arg1)->b);
6412   jresult = result;
6413   return jresult;
6414 }
6415
6416
6417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
6418   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6419
6420   arg1 = (Dali::Vector3 *)jarg1;
6421   {
6422     try {
6423       delete arg1;
6424     } catch (std::out_of_range& e) {
6425       {
6426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6427       };
6428     } catch (std::exception& e) {
6429       {
6430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6431       };
6432     } catch (...) {
6433       {
6434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6435       };
6436     }
6437   }
6438 }
6439
6440
6441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
6442   void * jresult ;
6443   Dali::Vector3 *arg1 = 0 ;
6444   Dali::Vector3 *arg2 = 0 ;
6445   Dali::Vector3 result;
6446
6447   arg1 = (Dali::Vector3 *)jarg1;
6448   if (!arg1) {
6449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6450     return 0;
6451   }
6452   arg2 = (Dali::Vector3 *)jarg2;
6453   if (!arg2) {
6454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6455     return 0;
6456   }
6457   {
6458     try {
6459       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6460     } catch (std::out_of_range& e) {
6461       {
6462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6463       };
6464     } catch (std::exception& e) {
6465       {
6466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6467       };
6468     } catch (...) {
6469       {
6470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6471       };
6472     }
6473   }
6474   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6475   return jresult;
6476 }
6477
6478
6479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
6480   void * jresult ;
6481   Dali::Vector3 *arg1 = 0 ;
6482   Dali::Vector3 *arg2 = 0 ;
6483   Dali::Vector3 result;
6484
6485   arg1 = (Dali::Vector3 *)jarg1;
6486   if (!arg1) {
6487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6488     return 0;
6489   }
6490   arg2 = (Dali::Vector3 *)jarg2;
6491   if (!arg2) {
6492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6493     return 0;
6494   }
6495   {
6496     try {
6497       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
6498     } catch (std::out_of_range& e) {
6499       {
6500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6501       };
6502     } catch (std::exception& e) {
6503       {
6504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6505       };
6506     } catch (...) {
6507       {
6508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6509       };
6510     }
6511   }
6512   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6513   return jresult;
6514 }
6515
6516
6517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
6518   void * jresult ;
6519   Dali::Vector3 *arg1 = 0 ;
6520   float *arg2 = 0 ;
6521   float *arg3 = 0 ;
6522   float temp2 ;
6523   float temp3 ;
6524   Dali::Vector3 result;
6525
6526   arg1 = (Dali::Vector3 *)jarg1;
6527   if (!arg1) {
6528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6529     return 0;
6530   }
6531   temp2 = (float)jarg2;
6532   arg2 = &temp2;
6533   temp3 = (float)jarg3;
6534   arg3 = &temp3;
6535   {
6536     try {
6537       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
6538     } catch (std::out_of_range& e) {
6539       {
6540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6541       };
6542     } catch (std::exception& e) {
6543       {
6544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6545       };
6546     } catch (...) {
6547       {
6548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6549       };
6550     }
6551   }
6552   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6553   return jresult;
6554 }
6555
6556
6557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
6558   void * jresult ;
6559   Dali::Vector4 *result = 0 ;
6560
6561   {
6562     try {
6563       result = (Dali::Vector4 *)new Dali::Vector4();
6564     } catch (std::out_of_range& e) {
6565       {
6566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6567       };
6568     } catch (std::exception& e) {
6569       {
6570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6571       };
6572     } catch (...) {
6573       {
6574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6575       };
6576     }
6577   }
6578   jresult = (void *)result;
6579   return jresult;
6580 }
6581
6582
6583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
6584   void * jresult ;
6585   float arg1 ;
6586   float arg2 ;
6587   float arg3 ;
6588   float arg4 ;
6589   Dali::Vector4 *result = 0 ;
6590
6591   arg1 = (float)jarg1;
6592   arg2 = (float)jarg2;
6593   arg3 = (float)jarg3;
6594   arg4 = (float)jarg4;
6595   {
6596     try {
6597       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
6598     } catch (std::out_of_range& e) {
6599       {
6600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6601       };
6602     } catch (std::exception& e) {
6603       {
6604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6605       };
6606     } catch (...) {
6607       {
6608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6609       };
6610     }
6611   }
6612   jresult = (void *)result;
6613   return jresult;
6614 }
6615
6616
6617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
6618   void * jresult ;
6619   float *arg1 = (float *) 0 ;
6620   Dali::Vector4 *result = 0 ;
6621
6622   arg1 = jarg1;
6623   {
6624     try {
6625       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
6626     } catch (std::out_of_range& e) {
6627       {
6628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6629       };
6630     } catch (std::exception& e) {
6631       {
6632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6633       };
6634     } catch (...) {
6635       {
6636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6637       };
6638     }
6639   }
6640   jresult = (void *)result;
6641
6642
6643   return jresult;
6644 }
6645
6646
6647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
6648   void * jresult ;
6649   Dali::Vector2 *arg1 = 0 ;
6650   Dali::Vector4 *result = 0 ;
6651
6652   arg1 = (Dali::Vector2 *)jarg1;
6653   if (!arg1) {
6654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6655     return 0;
6656   }
6657   {
6658     try {
6659       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
6660     } catch (std::out_of_range& e) {
6661       {
6662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6663       };
6664     } catch (std::exception& e) {
6665       {
6666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6667       };
6668     } catch (...) {
6669       {
6670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6671       };
6672     }
6673   }
6674   jresult = (void *)result;
6675   return jresult;
6676 }
6677
6678
6679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
6680   void * jresult ;
6681   Dali::Vector3 *arg1 = 0 ;
6682   Dali::Vector4 *result = 0 ;
6683
6684   arg1 = (Dali::Vector3 *)jarg1;
6685   if (!arg1) {
6686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6687     return 0;
6688   }
6689   {
6690     try {
6691       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
6692     } catch (std::out_of_range& e) {
6693       {
6694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6695       };
6696     } catch (std::exception& e) {
6697       {
6698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6699       };
6700     } catch (...) {
6701       {
6702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6703       };
6704     }
6705   }
6706   jresult = (void *)result;
6707   return jresult;
6708 }
6709
6710
6711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
6712   void * jresult ;
6713   Dali::Vector4 *result = 0 ;
6714
6715   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
6716   jresult = (void *)result;
6717   return jresult;
6718 }
6719
6720
6721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
6722   void * jresult ;
6723   Dali::Vector4 *result = 0 ;
6724
6725   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
6726   jresult = (void *)result;
6727   return jresult;
6728 }
6729
6730
6731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
6732   void * jresult ;
6733   Dali::Vector4 *result = 0 ;
6734
6735   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
6736   jresult = (void *)result;
6737   return jresult;
6738 }
6739
6740
6741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
6742   void * jresult ;
6743   Dali::Vector4 *result = 0 ;
6744
6745   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
6746   jresult = (void *)result;
6747   return jresult;
6748 }
6749
6750
6751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
6752   void * jresult ;
6753   Dali::Vector4 *result = 0 ;
6754
6755   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
6756   jresult = (void *)result;
6757   return jresult;
6758 }
6759
6760
6761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
6762   void * jresult ;
6763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6764   float *arg2 = (float *) 0 ;
6765   Dali::Vector4 *result = 0 ;
6766
6767   arg1 = (Dali::Vector4 *)jarg1;
6768   arg2 = jarg2;
6769   {
6770     try {
6771       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
6772     } catch (std::out_of_range& e) {
6773       {
6774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6775       };
6776     } catch (std::exception& e) {
6777       {
6778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6779       };
6780     } catch (...) {
6781       {
6782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6783       };
6784     }
6785   }
6786   jresult = (void *)result;
6787
6788
6789   return jresult;
6790 }
6791
6792
6793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
6794   void * jresult ;
6795   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6796   Dali::Vector2 *arg2 = 0 ;
6797   Dali::Vector4 *result = 0 ;
6798
6799   arg1 = (Dali::Vector4 *)jarg1;
6800   arg2 = (Dali::Vector2 *)jarg2;
6801   if (!arg2) {
6802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
6803     return 0;
6804   }
6805   {
6806     try {
6807       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
6808     } catch (std::out_of_range& e) {
6809       {
6810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6811       };
6812     } catch (std::exception& e) {
6813       {
6814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6815       };
6816     } catch (...) {
6817       {
6818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6819       };
6820     }
6821   }
6822   jresult = (void *)result;
6823   return jresult;
6824 }
6825
6826
6827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
6828   void * jresult ;
6829   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6830   Dali::Vector3 *arg2 = 0 ;
6831   Dali::Vector4 *result = 0 ;
6832
6833   arg1 = (Dali::Vector4 *)jarg1;
6834   arg2 = (Dali::Vector3 *)jarg2;
6835   if (!arg2) {
6836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6837     return 0;
6838   }
6839   {
6840     try {
6841       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
6842     } catch (std::out_of_range& e) {
6843       {
6844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6845       };
6846     } catch (std::exception& e) {
6847       {
6848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6849       };
6850     } catch (...) {
6851       {
6852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6853       };
6854     }
6855   }
6856   jresult = (void *)result;
6857   return jresult;
6858 }
6859
6860
6861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
6862   void * jresult ;
6863   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6864   Dali::Vector4 *arg2 = 0 ;
6865   Dali::Vector4 result;
6866
6867   arg1 = (Dali::Vector4 *)jarg1;
6868   arg2 = (Dali::Vector4 *)jarg2;
6869   if (!arg2) {
6870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6871     return 0;
6872   }
6873   {
6874     try {
6875       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
6876     } catch (std::out_of_range& e) {
6877       {
6878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6879       };
6880     } catch (std::exception& e) {
6881       {
6882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6883       };
6884     } catch (...) {
6885       {
6886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6887       };
6888     }
6889   }
6890   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6891   return jresult;
6892 }
6893
6894
6895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
6896   void * jresult ;
6897   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6898   Dali::Vector4 *arg2 = 0 ;
6899   Dali::Vector4 *result = 0 ;
6900
6901   arg1 = (Dali::Vector4 *)jarg1;
6902   arg2 = (Dali::Vector4 *)jarg2;
6903   if (!arg2) {
6904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6905     return 0;
6906   }
6907   {
6908     try {
6909       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
6910     } catch (std::out_of_range& e) {
6911       {
6912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6913       };
6914     } catch (std::exception& e) {
6915       {
6916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6917       };
6918     } catch (...) {
6919       {
6920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6921       };
6922     }
6923   }
6924   jresult = (void *)result;
6925   return jresult;
6926 }
6927
6928
6929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6930   void * jresult ;
6931   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6932   Dali::Vector4 *arg2 = 0 ;
6933   Dali::Vector4 result;
6934
6935   arg1 = (Dali::Vector4 *)jarg1;
6936   arg2 = (Dali::Vector4 *)jarg2;
6937   if (!arg2) {
6938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6939     return 0;
6940   }
6941   {
6942     try {
6943       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
6944     } catch (std::out_of_range& e) {
6945       {
6946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6947       };
6948     } catch (std::exception& e) {
6949       {
6950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6951       };
6952     } catch (...) {
6953       {
6954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6955       };
6956     }
6957   }
6958   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
6959   return jresult;
6960 }
6961
6962
6963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
6964   void * jresult ;
6965   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
6966   Dali::Vector4 *arg2 = 0 ;
6967   Dali::Vector4 *result = 0 ;
6968
6969   arg1 = (Dali::Vector4 *)jarg1;
6970   arg2 = (Dali::Vector4 *)jarg2;
6971   if (!arg2) {
6972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
6973     return 0;
6974   }
6975   {
6976     try {
6977       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
6978     } catch (std::out_of_range& e) {
6979       {
6980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6981       };
6982     } catch (std::exception& e) {
6983       {
6984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6985       };
6986     } catch (...) {
6987       {
6988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6989       };
6990     }
6991   }
6992   jresult = (void *)result;
6993   return jresult;
6994 }
6995
6996
6997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6998   void * jresult ;
6999   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7000   Dali::Vector4 *arg2 = 0 ;
7001   Dali::Vector4 result;
7002
7003   arg1 = (Dali::Vector4 *)jarg1;
7004   arg2 = (Dali::Vector4 *)jarg2;
7005   if (!arg2) {
7006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7007     return 0;
7008   }
7009   {
7010     try {
7011       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7012     } catch (std::out_of_range& e) {
7013       {
7014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7015       };
7016     } catch (std::exception& e) {
7017       {
7018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7019       };
7020     } catch (...) {
7021       {
7022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7023       };
7024     }
7025   }
7026   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7027   return jresult;
7028 }
7029
7030
7031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7032   void * jresult ;
7033   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7034   float arg2 ;
7035   Dali::Vector4 result;
7036
7037   arg1 = (Dali::Vector4 *)jarg1;
7038   arg2 = (float)jarg2;
7039   {
7040     try {
7041       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7042     } catch (std::out_of_range& e) {
7043       {
7044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7045       };
7046     } catch (std::exception& e) {
7047       {
7048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7049       };
7050     } catch (...) {
7051       {
7052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7053       };
7054     }
7055   }
7056   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7057   return jresult;
7058 }
7059
7060
7061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7062   void * jresult ;
7063   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7064   Dali::Vector4 *arg2 = 0 ;
7065   Dali::Vector4 *result = 0 ;
7066
7067   arg1 = (Dali::Vector4 *)jarg1;
7068   arg2 = (Dali::Vector4 *)jarg2;
7069   if (!arg2) {
7070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7071     return 0;
7072   }
7073   {
7074     try {
7075       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7076     } catch (std::out_of_range& e) {
7077       {
7078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7079       };
7080     } catch (std::exception& e) {
7081       {
7082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7083       };
7084     } catch (...) {
7085       {
7086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7087       };
7088     }
7089   }
7090   jresult = (void *)result;
7091   return jresult;
7092 }
7093
7094
7095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7096   void * jresult ;
7097   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7098   float arg2 ;
7099   Dali::Vector4 *result = 0 ;
7100
7101   arg1 = (Dali::Vector4 *)jarg1;
7102   arg2 = (float)jarg2;
7103   {
7104     try {
7105       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7106     } catch (std::out_of_range& e) {
7107       {
7108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7109       };
7110     } catch (std::exception& e) {
7111       {
7112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7113       };
7114     } catch (...) {
7115       {
7116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7117       };
7118     }
7119   }
7120   jresult = (void *)result;
7121   return jresult;
7122 }
7123
7124
7125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7126   void * jresult ;
7127   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7128   Dali::Vector4 *arg2 = 0 ;
7129   Dali::Vector4 result;
7130
7131   arg1 = (Dali::Vector4 *)jarg1;
7132   arg2 = (Dali::Vector4 *)jarg2;
7133   if (!arg2) {
7134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7135     return 0;
7136   }
7137   {
7138     try {
7139       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7140     } catch (std::out_of_range& e) {
7141       {
7142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7143       };
7144     } catch (std::exception& e) {
7145       {
7146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7147       };
7148     } catch (...) {
7149       {
7150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7151       };
7152     }
7153   }
7154   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7155   return jresult;
7156 }
7157
7158
7159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7160   void * jresult ;
7161   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7162   float arg2 ;
7163   Dali::Vector4 result;
7164
7165   arg1 = (Dali::Vector4 *)jarg1;
7166   arg2 = (float)jarg2;
7167   {
7168     try {
7169       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7170     } catch (std::out_of_range& e) {
7171       {
7172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7173       };
7174     } catch (std::exception& e) {
7175       {
7176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7177       };
7178     } catch (...) {
7179       {
7180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7181       };
7182     }
7183   }
7184   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7185   return jresult;
7186 }
7187
7188
7189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7190   void * jresult ;
7191   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7192   Dali::Vector4 *arg2 = 0 ;
7193   Dali::Vector4 *result = 0 ;
7194
7195   arg1 = (Dali::Vector4 *)jarg1;
7196   arg2 = (Dali::Vector4 *)jarg2;
7197   if (!arg2) {
7198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7199     return 0;
7200   }
7201   {
7202     try {
7203       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7204     } catch (std::out_of_range& e) {
7205       {
7206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7207       };
7208     } catch (std::exception& e) {
7209       {
7210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7211       };
7212     } catch (...) {
7213       {
7214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7215       };
7216     }
7217   }
7218   jresult = (void *)result;
7219   return jresult;
7220 }
7221
7222
7223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7224   void * jresult ;
7225   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7226   float arg2 ;
7227   Dali::Vector4 *result = 0 ;
7228
7229   arg1 = (Dali::Vector4 *)jarg1;
7230   arg2 = (float)jarg2;
7231   {
7232     try {
7233       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7234     } catch (std::out_of_range& e) {
7235       {
7236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7237       };
7238     } catch (std::exception& e) {
7239       {
7240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7241       };
7242     } catch (...) {
7243       {
7244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7245       };
7246     }
7247   }
7248   jresult = (void *)result;
7249   return jresult;
7250 }
7251
7252
7253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
7254   void * jresult ;
7255   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7256   Dali::Vector4 result;
7257
7258   arg1 = (Dali::Vector4 *)jarg1;
7259   {
7260     try {
7261       result = ((Dali::Vector4 const *)arg1)->operator -();
7262     } catch (std::out_of_range& e) {
7263       {
7264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7265       };
7266     } catch (std::exception& e) {
7267       {
7268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7269       };
7270     } catch (...) {
7271       {
7272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7273       };
7274     }
7275   }
7276   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7277   return jresult;
7278 }
7279
7280
7281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
7282   unsigned int jresult ;
7283   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7284   Dali::Vector4 *arg2 = 0 ;
7285   bool result;
7286
7287   arg1 = (Dali::Vector4 *)jarg1;
7288   arg2 = (Dali::Vector4 *)jarg2;
7289   if (!arg2) {
7290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7291     return 0;
7292   }
7293   {
7294     try {
7295       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
7296     } catch (std::out_of_range& e) {
7297       {
7298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7299       };
7300     } catch (std::exception& e) {
7301       {
7302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7303       };
7304     } catch (...) {
7305       {
7306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7307       };
7308     }
7309   }
7310   jresult = result;
7311   return jresult;
7312 }
7313
7314
7315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
7316   unsigned int jresult ;
7317   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7318   Dali::Vector4 *arg2 = 0 ;
7319   bool result;
7320
7321   arg1 = (Dali::Vector4 *)jarg1;
7322   arg2 = (Dali::Vector4 *)jarg2;
7323   if (!arg2) {
7324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7325     return 0;
7326   }
7327   {
7328     try {
7329       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
7330     } catch (std::out_of_range& e) {
7331       {
7332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7333       };
7334     } catch (std::exception& e) {
7335       {
7336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7337       };
7338     } catch (...) {
7339       {
7340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7341       };
7342     }
7343   }
7344   jresult = result;
7345   return jresult;
7346 }
7347
7348
7349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
7350   float jresult ;
7351   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7352   unsigned int arg2 ;
7353   float *result = 0 ;
7354
7355   arg1 = (Dali::Vector4 *)jarg1;
7356   arg2 = (unsigned int)jarg2;
7357   {
7358     try {
7359       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
7360     } catch (std::out_of_range& e) {
7361       {
7362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7363       };
7364     } catch (std::exception& e) {
7365       {
7366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7367       };
7368     } catch (...) {
7369       {
7370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7371       };
7372     }
7373   }
7374   jresult = *result;
7375   return jresult;
7376 }
7377
7378
7379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
7380   float jresult ;
7381   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7382   Dali::Vector3 *arg2 = 0 ;
7383   float result;
7384
7385   arg1 = (Dali::Vector4 *)jarg1;
7386   arg2 = (Dali::Vector3 *)jarg2;
7387   if (!arg2) {
7388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7389     return 0;
7390   }
7391   {
7392     try {
7393       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
7394     } catch (std::out_of_range& e) {
7395       {
7396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7397       };
7398     } catch (std::exception& e) {
7399       {
7400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7401       };
7402     } catch (...) {
7403       {
7404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7405       };
7406     }
7407   }
7408   jresult = result;
7409   return jresult;
7410 }
7411
7412
7413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
7414   float jresult ;
7415   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7416   Dali::Vector4 *arg2 = 0 ;
7417   float result;
7418
7419   arg1 = (Dali::Vector4 *)jarg1;
7420   arg2 = (Dali::Vector4 *)jarg2;
7421   if (!arg2) {
7422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7423     return 0;
7424   }
7425   {
7426     try {
7427       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
7428     } catch (std::out_of_range& e) {
7429       {
7430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7431       };
7432     } catch (std::exception& e) {
7433       {
7434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7435       };
7436     } catch (...) {
7437       {
7438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7439       };
7440     }
7441   }
7442   jresult = result;
7443   return jresult;
7444 }
7445
7446
7447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
7448   float jresult ;
7449   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7450   Dali::Vector4 *arg2 = 0 ;
7451   float result;
7452
7453   arg1 = (Dali::Vector4 *)jarg1;
7454   arg2 = (Dali::Vector4 *)jarg2;
7455   if (!arg2) {
7456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7457     return 0;
7458   }
7459   {
7460     try {
7461       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
7462     } catch (std::out_of_range& e) {
7463       {
7464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7465       };
7466     } catch (std::exception& e) {
7467       {
7468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7469       };
7470     } catch (...) {
7471       {
7472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7473       };
7474     }
7475   }
7476   jresult = result;
7477   return jresult;
7478 }
7479
7480
7481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
7482   void * jresult ;
7483   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7484   Dali::Vector4 *arg2 = 0 ;
7485   Dali::Vector4 result;
7486
7487   arg1 = (Dali::Vector4 *)jarg1;
7488   arg2 = (Dali::Vector4 *)jarg2;
7489   if (!arg2) {
7490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7491     return 0;
7492   }
7493   {
7494     try {
7495       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
7496     } catch (std::out_of_range& e) {
7497       {
7498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7499       };
7500     } catch (std::exception& e) {
7501       {
7502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7503       };
7504     } catch (...) {
7505       {
7506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7507       };
7508     }
7509   }
7510   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7511   return jresult;
7512 }
7513
7514
7515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
7516   float jresult ;
7517   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7518   float result;
7519
7520   arg1 = (Dali::Vector4 *)jarg1;
7521   {
7522     try {
7523       result = (float)((Dali::Vector4 const *)arg1)->Length();
7524     } catch (std::out_of_range& e) {
7525       {
7526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7527       };
7528     } catch (std::exception& e) {
7529       {
7530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7531       };
7532     } catch (...) {
7533       {
7534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7535       };
7536     }
7537   }
7538   jresult = result;
7539   return jresult;
7540 }
7541
7542
7543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
7544   float jresult ;
7545   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7546   float result;
7547
7548   arg1 = (Dali::Vector4 *)jarg1;
7549   {
7550     try {
7551       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
7552     } catch (std::out_of_range& e) {
7553       {
7554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7555       };
7556     } catch (std::exception& e) {
7557       {
7558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7559       };
7560     } catch (...) {
7561       {
7562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7563       };
7564     }
7565   }
7566   jresult = result;
7567   return jresult;
7568 }
7569
7570
7571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
7572   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7573
7574   arg1 = (Dali::Vector4 *)jarg1;
7575   {
7576     try {
7577       (arg1)->Normalize();
7578     } catch (std::out_of_range& e) {
7579       {
7580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7581       };
7582     } catch (std::exception& e) {
7583       {
7584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7585       };
7586     } catch (...) {
7587       {
7588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7589       };
7590     }
7591   }
7592 }
7593
7594
7595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
7596   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7597   Dali::Vector4 *arg2 = 0 ;
7598   Dali::Vector4 *arg3 = 0 ;
7599
7600   arg1 = (Dali::Vector4 *)jarg1;
7601   arg2 = (Dali::Vector4 *)jarg2;
7602   if (!arg2) {
7603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7604     return ;
7605   }
7606   arg3 = (Dali::Vector4 *)jarg3;
7607   if (!arg3) {
7608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7609     return ;
7610   }
7611   {
7612     try {
7613       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
7614     } catch (std::out_of_range& e) {
7615       {
7616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7617       };
7618     } catch (std::exception& e) {
7619       {
7620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7621       };
7622     } catch (...) {
7623       {
7624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7625       };
7626     }
7627   }
7628 }
7629
7630
7631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
7632   void * jresult ;
7633   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7634   float *result = 0 ;
7635
7636   arg1 = (Dali::Vector4 *)jarg1;
7637   {
7638     try {
7639       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
7640     } catch (std::out_of_range& e) {
7641       {
7642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7643       };
7644     } catch (std::exception& e) {
7645       {
7646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7647       };
7648     } catch (...) {
7649       {
7650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7651       };
7652     }
7653   }
7654   jresult = (void *)result;
7655   return jresult;
7656 }
7657
7658
7659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
7660   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7661   float arg2 ;
7662
7663   arg1 = (Dali::Vector4 *)jarg1;
7664   arg2 = (float)jarg2;
7665   if (arg1) (arg1)->x = arg2;
7666 }
7667
7668
7669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
7670   float jresult ;
7671   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7672   float result;
7673
7674   arg1 = (Dali::Vector4 *)jarg1;
7675   result = (float) ((arg1)->x);
7676   jresult = result;
7677   return jresult;
7678 }
7679
7680
7681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
7682   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7683   float arg2 ;
7684
7685   arg1 = (Dali::Vector4 *)jarg1;
7686   arg2 = (float)jarg2;
7687   if (arg1) (arg1)->r = arg2;
7688 }
7689
7690
7691 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
7692   float jresult ;
7693   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7694   float result;
7695
7696   arg1 = (Dali::Vector4 *)jarg1;
7697   result = (float) ((arg1)->r);
7698   jresult = result;
7699   return jresult;
7700 }
7701
7702
7703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
7704   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7705   float arg2 ;
7706
7707   arg1 = (Dali::Vector4 *)jarg1;
7708   arg2 = (float)jarg2;
7709   if (arg1) (arg1)->s = arg2;
7710 }
7711
7712
7713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
7714   float jresult ;
7715   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7716   float result;
7717
7718   arg1 = (Dali::Vector4 *)jarg1;
7719   result = (float) ((arg1)->s);
7720   jresult = result;
7721   return jresult;
7722 }
7723
7724
7725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
7726   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7727   float arg2 ;
7728
7729   arg1 = (Dali::Vector4 *)jarg1;
7730   arg2 = (float)jarg2;
7731   if (arg1) (arg1)->y = arg2;
7732 }
7733
7734
7735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
7736   float jresult ;
7737   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7738   float result;
7739
7740   arg1 = (Dali::Vector4 *)jarg1;
7741   result = (float) ((arg1)->y);
7742   jresult = result;
7743   return jresult;
7744 }
7745
7746
7747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
7748   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7749   float arg2 ;
7750
7751   arg1 = (Dali::Vector4 *)jarg1;
7752   arg2 = (float)jarg2;
7753   if (arg1) (arg1)->g = arg2;
7754 }
7755
7756
7757 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
7758   float jresult ;
7759   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7760   float result;
7761
7762   arg1 = (Dali::Vector4 *)jarg1;
7763   result = (float) ((arg1)->g);
7764   jresult = result;
7765   return jresult;
7766 }
7767
7768
7769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
7770   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7771   float arg2 ;
7772
7773   arg1 = (Dali::Vector4 *)jarg1;
7774   arg2 = (float)jarg2;
7775   if (arg1) (arg1)->t = arg2;
7776 }
7777
7778
7779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
7780   float jresult ;
7781   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7782   float result;
7783
7784   arg1 = (Dali::Vector4 *)jarg1;
7785   result = (float) ((arg1)->t);
7786   jresult = result;
7787   return jresult;
7788 }
7789
7790
7791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
7792   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7793   float arg2 ;
7794
7795   arg1 = (Dali::Vector4 *)jarg1;
7796   arg2 = (float)jarg2;
7797   if (arg1) (arg1)->z = arg2;
7798 }
7799
7800
7801 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
7802   float jresult ;
7803   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7804   float result;
7805
7806   arg1 = (Dali::Vector4 *)jarg1;
7807   result = (float) ((arg1)->z);
7808   jresult = result;
7809   return jresult;
7810 }
7811
7812
7813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
7814   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7815   float arg2 ;
7816
7817   arg1 = (Dali::Vector4 *)jarg1;
7818   arg2 = (float)jarg2;
7819   if (arg1) (arg1)->b = arg2;
7820 }
7821
7822
7823 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
7824   float jresult ;
7825   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7826   float result;
7827
7828   arg1 = (Dali::Vector4 *)jarg1;
7829   result = (float) ((arg1)->b);
7830   jresult = result;
7831   return jresult;
7832 }
7833
7834
7835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
7836   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7837   float arg2 ;
7838
7839   arg1 = (Dali::Vector4 *)jarg1;
7840   arg2 = (float)jarg2;
7841   if (arg1) (arg1)->p = arg2;
7842 }
7843
7844
7845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
7846   float jresult ;
7847   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7848   float result;
7849
7850   arg1 = (Dali::Vector4 *)jarg1;
7851   result = (float) ((arg1)->p);
7852   jresult = result;
7853   return jresult;
7854 }
7855
7856
7857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
7858   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7859   float arg2 ;
7860
7861   arg1 = (Dali::Vector4 *)jarg1;
7862   arg2 = (float)jarg2;
7863   if (arg1) (arg1)->w = arg2;
7864 }
7865
7866
7867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
7868   float jresult ;
7869   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7870   float result;
7871
7872   arg1 = (Dali::Vector4 *)jarg1;
7873   result = (float) ((arg1)->w);
7874   jresult = result;
7875   return jresult;
7876 }
7877
7878
7879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
7880   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7881   float arg2 ;
7882
7883   arg1 = (Dali::Vector4 *)jarg1;
7884   arg2 = (float)jarg2;
7885   if (arg1) (arg1)->a = arg2;
7886 }
7887
7888
7889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
7890   float jresult ;
7891   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7892   float result;
7893
7894   arg1 = (Dali::Vector4 *)jarg1;
7895   result = (float) ((arg1)->a);
7896   jresult = result;
7897   return jresult;
7898 }
7899
7900
7901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
7902   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7903   float arg2 ;
7904
7905   arg1 = (Dali::Vector4 *)jarg1;
7906   arg2 = (float)jarg2;
7907   if (arg1) (arg1)->q = arg2;
7908 }
7909
7910
7911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
7912   float jresult ;
7913   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7914   float result;
7915
7916   arg1 = (Dali::Vector4 *)jarg1;
7917   result = (float) ((arg1)->q);
7918   jresult = result;
7919   return jresult;
7920 }
7921
7922
7923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
7924   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7925
7926   arg1 = (Dali::Vector4 *)jarg1;
7927   {
7928     try {
7929       delete arg1;
7930     } catch (std::out_of_range& e) {
7931       {
7932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7933       };
7934     } catch (std::exception& e) {
7935       {
7936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7937       };
7938     } catch (...) {
7939       {
7940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7941       };
7942     }
7943   }
7944 }
7945
7946
7947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
7948   void * jresult ;
7949   Dali::Vector4 *arg1 = 0 ;
7950   Dali::Vector4 *arg2 = 0 ;
7951   Dali::Vector4 result;
7952
7953   arg1 = (Dali::Vector4 *)jarg1;
7954   if (!arg1) {
7955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7956     return 0;
7957   }
7958   arg2 = (Dali::Vector4 *)jarg2;
7959   if (!arg2) {
7960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7961     return 0;
7962   }
7963   {
7964     try {
7965       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
7966     } catch (std::out_of_range& e) {
7967       {
7968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7969       };
7970     } catch (std::exception& e) {
7971       {
7972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7973       };
7974     } catch (...) {
7975       {
7976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7977       };
7978     }
7979   }
7980   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7981   return jresult;
7982 }
7983
7984
7985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
7986   void * jresult ;
7987   Dali::Vector4 *arg1 = 0 ;
7988   Dali::Vector4 *arg2 = 0 ;
7989   Dali::Vector4 result;
7990
7991   arg1 = (Dali::Vector4 *)jarg1;
7992   if (!arg1) {
7993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7994     return 0;
7995   }
7996   arg2 = (Dali::Vector4 *)jarg2;
7997   if (!arg2) {
7998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7999     return 0;
8000   }
8001   {
8002     try {
8003       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8004     } catch (std::out_of_range& e) {
8005       {
8006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8007       };
8008     } catch (std::exception& e) {
8009       {
8010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8011       };
8012     } catch (...) {
8013       {
8014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8015       };
8016     }
8017   }
8018   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8019   return jresult;
8020 }
8021
8022
8023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8024   void * jresult ;
8025   Dali::Vector4 *arg1 = 0 ;
8026   float *arg2 = 0 ;
8027   float *arg3 = 0 ;
8028   float temp2 ;
8029   float temp3 ;
8030   Dali::Vector4 result;
8031
8032   arg1 = (Dali::Vector4 *)jarg1;
8033   if (!arg1) {
8034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8035     return 0;
8036   }
8037   temp2 = (float)jarg2;
8038   arg2 = &temp2;
8039   temp3 = (float)jarg3;
8040   arg3 = &temp3;
8041   {
8042     try {
8043       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8044     } catch (std::out_of_range& e) {
8045       {
8046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8047       };
8048     } catch (std::exception& e) {
8049       {
8050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8051       };
8052     } catch (...) {
8053       {
8054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8055       };
8056     }
8057   }
8058   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8059   return jresult;
8060 }
8061
8062
8063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8064   void * jresult ;
8065   Dali::Uint16Pair *result = 0 ;
8066
8067   {
8068     try {
8069       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8070     } catch (std::out_of_range& e) {
8071       {
8072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8073       };
8074     } catch (std::exception& e) {
8075       {
8076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8077       };
8078     } catch (...) {
8079       {
8080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8081       };
8082     }
8083   }
8084   jresult = (void *)result;
8085   return jresult;
8086 }
8087
8088
8089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8090   void * jresult ;
8091   uint32_t arg1 ;
8092   uint32_t arg2 ;
8093   Dali::Uint16Pair *result = 0 ;
8094
8095   arg1 = (uint32_t)jarg1;
8096   arg2 = (uint32_t)jarg2;
8097   {
8098     try {
8099       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8100     } catch (std::out_of_range& e) {
8101       {
8102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8103       };
8104     } catch (std::exception& e) {
8105       {
8106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8107       };
8108     } catch (...) {
8109       {
8110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8111       };
8112     }
8113   }
8114   jresult = (void *)result;
8115   return jresult;
8116 }
8117
8118
8119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8120   void * jresult ;
8121   Dali::Uint16Pair *arg1 = 0 ;
8122   Dali::Uint16Pair *result = 0 ;
8123
8124   arg1 = (Dali::Uint16Pair *)jarg1;
8125   if (!arg1) {
8126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8127     return 0;
8128   }
8129   {
8130     try {
8131       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8132     } catch (std::out_of_range& e) {
8133       {
8134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8135       };
8136     } catch (std::exception& e) {
8137       {
8138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8139       };
8140     } catch (...) {
8141       {
8142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8143       };
8144     }
8145   }
8146   jresult = (void *)result;
8147   return jresult;
8148 }
8149
8150
8151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
8152   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8153   uint16_t arg2 ;
8154
8155   arg1 = (Dali::Uint16Pair *)jarg1;
8156   arg2 = (uint16_t)jarg2;
8157   {
8158     try {
8159       (arg1)->SetWidth(arg2);
8160     } catch (std::out_of_range& e) {
8161       {
8162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8163       };
8164     } catch (std::exception& e) {
8165       {
8166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8167       };
8168     } catch (...) {
8169       {
8170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8171       };
8172     }
8173   }
8174 }
8175
8176
8177 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
8178   unsigned short jresult ;
8179   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8180   uint16_t result;
8181
8182   arg1 = (Dali::Uint16Pair *)jarg1;
8183   {
8184     try {
8185       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
8186     } catch (std::out_of_range& e) {
8187       {
8188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8189       };
8190     } catch (std::exception& e) {
8191       {
8192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8193       };
8194     } catch (...) {
8195       {
8196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8197       };
8198     }
8199   }
8200   jresult = result;
8201   return jresult;
8202 }
8203
8204
8205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
8206   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8207   uint16_t arg2 ;
8208
8209   arg1 = (Dali::Uint16Pair *)jarg1;
8210   arg2 = (uint16_t)jarg2;
8211   {
8212     try {
8213       (arg1)->SetHeight(arg2);
8214     } catch (std::out_of_range& e) {
8215       {
8216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8217       };
8218     } catch (std::exception& e) {
8219       {
8220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8221       };
8222     } catch (...) {
8223       {
8224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8225       };
8226     }
8227   }
8228 }
8229
8230
8231 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
8232   unsigned short jresult ;
8233   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8234   uint16_t result;
8235
8236   arg1 = (Dali::Uint16Pair *)jarg1;
8237   {
8238     try {
8239       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
8240     } catch (std::out_of_range& e) {
8241       {
8242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8243       };
8244     } catch (std::exception& e) {
8245       {
8246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8247       };
8248     } catch (...) {
8249       {
8250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8251       };
8252     }
8253   }
8254   jresult = result;
8255   return jresult;
8256 }
8257
8258
8259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
8260   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8261   uint16_t arg2 ;
8262
8263   arg1 = (Dali::Uint16Pair *)jarg1;
8264   arg2 = (uint16_t)jarg2;
8265   {
8266     try {
8267       (arg1)->SetX(arg2);
8268     } catch (std::out_of_range& e) {
8269       {
8270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8271       };
8272     } catch (std::exception& e) {
8273       {
8274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8275       };
8276     } catch (...) {
8277       {
8278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8279       };
8280     }
8281   }
8282 }
8283
8284
8285 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
8286   unsigned short jresult ;
8287   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8288   uint16_t result;
8289
8290   arg1 = (Dali::Uint16Pair *)jarg1;
8291   {
8292     try {
8293       result = ((Dali::Uint16Pair const *)arg1)->GetX();
8294     } catch (std::out_of_range& e) {
8295       {
8296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8297       };
8298     } catch (std::exception& e) {
8299       {
8300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8301       };
8302     } catch (...) {
8303       {
8304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8305       };
8306     }
8307   }
8308   jresult = result;
8309   return jresult;
8310 }
8311
8312
8313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
8314   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8315   uint16_t arg2 ;
8316
8317   arg1 = (Dali::Uint16Pair *)jarg1;
8318   arg2 = (uint16_t)jarg2;
8319   {
8320     try {
8321       (arg1)->SetY(arg2);
8322     } catch (std::out_of_range& e) {
8323       {
8324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8325       };
8326     } catch (std::exception& e) {
8327       {
8328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8329       };
8330     } catch (...) {
8331       {
8332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8333       };
8334     }
8335   }
8336 }
8337
8338
8339 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
8340   unsigned short jresult ;
8341   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8342   uint16_t result;
8343
8344   arg1 = (Dali::Uint16Pair *)jarg1;
8345   {
8346     try {
8347       result = ((Dali::Uint16Pair const *)arg1)->GetY();
8348     } catch (std::out_of_range& e) {
8349       {
8350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8351       };
8352     } catch (std::exception& e) {
8353       {
8354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8355       };
8356     } catch (...) {
8357       {
8358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8359       };
8360     }
8361   }
8362   jresult = result;
8363   return jresult;
8364 }
8365
8366
8367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
8368   void * jresult ;
8369   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8370   Dali::Uint16Pair *arg2 = 0 ;
8371   Dali::Uint16Pair *result = 0 ;
8372
8373   arg1 = (Dali::Uint16Pair *)jarg1;
8374   arg2 = (Dali::Uint16Pair *)jarg2;
8375   if (!arg2) {
8376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8377     return 0;
8378   }
8379   {
8380     try {
8381       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
8382     } catch (std::out_of_range& e) {
8383       {
8384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8385       };
8386     } catch (std::exception& e) {
8387       {
8388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8389       };
8390     } catch (...) {
8391       {
8392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8393       };
8394     }
8395   }
8396   jresult = (void *)result;
8397   return jresult;
8398 }
8399
8400
8401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
8402   unsigned int jresult ;
8403   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8404   Dali::Uint16Pair *arg2 = 0 ;
8405   bool result;
8406
8407   arg1 = (Dali::Uint16Pair *)jarg1;
8408   arg2 = (Dali::Uint16Pair *)jarg2;
8409   if (!arg2) {
8410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8411     return 0;
8412   }
8413   {
8414     try {
8415       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
8416     } catch (std::out_of_range& e) {
8417       {
8418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8419       };
8420     } catch (std::exception& e) {
8421       {
8422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8423       };
8424     } catch (...) {
8425       {
8426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8427       };
8428     }
8429   }
8430   jresult = result;
8431   return jresult;
8432 }
8433
8434
8435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
8436   unsigned int jresult ;
8437   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8438   Dali::Uint16Pair *arg2 = 0 ;
8439   bool result;
8440
8441   arg1 = (Dali::Uint16Pair *)jarg1;
8442   arg2 = (Dali::Uint16Pair *)jarg2;
8443   if (!arg2) {
8444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8445     return 0;
8446   }
8447   {
8448     try {
8449       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
8450     } catch (std::out_of_range& e) {
8451       {
8452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8453       };
8454     } catch (std::exception& e) {
8455       {
8456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8457       };
8458     } catch (...) {
8459       {
8460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8461       };
8462     }
8463   }
8464   jresult = result;
8465   return jresult;
8466 }
8467
8468
8469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
8470   unsigned int jresult ;
8471   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8472   Dali::Uint16Pair *arg2 = 0 ;
8473   bool result;
8474
8475   arg1 = (Dali::Uint16Pair *)jarg1;
8476   arg2 = (Dali::Uint16Pair *)jarg2;
8477   if (!arg2) {
8478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8479     return 0;
8480   }
8481   {
8482     try {
8483       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
8484     } catch (std::out_of_range& e) {
8485       {
8486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8487       };
8488     } catch (std::exception& e) {
8489       {
8490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8491       };
8492     } catch (...) {
8493       {
8494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8495       };
8496     }
8497   }
8498   jresult = result;
8499   return jresult;
8500 }
8501
8502
8503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
8504   unsigned int jresult ;
8505   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8506   Dali::Uint16Pair *arg2 = 0 ;
8507   bool result;
8508
8509   arg1 = (Dali::Uint16Pair *)jarg1;
8510   arg2 = (Dali::Uint16Pair *)jarg2;
8511   if (!arg2) {
8512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8513     return 0;
8514   }
8515   {
8516     try {
8517       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
8518     } catch (std::out_of_range& e) {
8519       {
8520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8521       };
8522     } catch (std::exception& e) {
8523       {
8524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8525       };
8526     } catch (...) {
8527       {
8528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8529       };
8530     }
8531   }
8532   jresult = result;
8533   return jresult;
8534 }
8535
8536
8537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
8538   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
8539
8540   arg1 = (Dali::Uint16Pair *)jarg1;
8541   {
8542     try {
8543       delete arg1;
8544     } catch (std::out_of_range& e) {
8545       {
8546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8547       };
8548     } catch (std::exception& e) {
8549       {
8550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8551       };
8552     } catch (...) {
8553       {
8554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8555       };
8556     }
8557   }
8558 }
8559
8560
8561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
8562   void * jresult ;
8563   Dali::Degree *result = 0 ;
8564
8565   {
8566     try {
8567       result = (Dali::Degree *)new Dali::Degree();
8568     } catch (std::out_of_range& e) {
8569       {
8570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8571       };
8572     } catch (std::exception& e) {
8573       {
8574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8575       };
8576     } catch (...) {
8577       {
8578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8579       };
8580     }
8581   }
8582   jresult = (void *)result;
8583   return jresult;
8584 }
8585
8586
8587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
8588   void * jresult ;
8589   float arg1 ;
8590   Dali::Degree *result = 0 ;
8591
8592   arg1 = (float)jarg1;
8593   {
8594     try {
8595       result = (Dali::Degree *)new Dali::Degree(arg1);
8596     } catch (std::out_of_range& e) {
8597       {
8598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8599       };
8600     } catch (std::exception& e) {
8601       {
8602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8603       };
8604     } catch (...) {
8605       {
8606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8607       };
8608     }
8609   }
8610   jresult = (void *)result;
8611   return jresult;
8612 }
8613
8614
8615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
8616   void * jresult ;
8617   Dali::Radian arg1 ;
8618   Dali::Radian *argp1 ;
8619   Dali::Degree *result = 0 ;
8620
8621   argp1 = (Dali::Radian *)jarg1;
8622   if (!argp1) {
8623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
8624     return 0;
8625   }
8626   arg1 = *argp1;
8627   {
8628     try {
8629       result = (Dali::Degree *)new Dali::Degree(arg1);
8630     } catch (std::out_of_range& e) {
8631       {
8632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8633       };
8634     } catch (std::exception& e) {
8635       {
8636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8637       };
8638     } catch (...) {
8639       {
8640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8641       };
8642     }
8643   }
8644   jresult = (void *)result;
8645   return jresult;
8646 }
8647
8648
8649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
8650   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8651   float arg2 ;
8652
8653   arg1 = (Dali::Degree *)jarg1;
8654   arg2 = (float)jarg2;
8655   if (arg1) (arg1)->degree = arg2;
8656 }
8657
8658
8659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
8660   float jresult ;
8661   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8662   float result;
8663
8664   arg1 = (Dali::Degree *)jarg1;
8665   result = (float) ((arg1)->degree);
8666   jresult = result;
8667   return jresult;
8668 }
8669
8670
8671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
8672   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
8673
8674   arg1 = (Dali::Degree *)jarg1;
8675   {
8676     try {
8677       delete arg1;
8678     } catch (std::out_of_range& e) {
8679       {
8680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8681       };
8682     } catch (std::exception& e) {
8683       {
8684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8685       };
8686     } catch (...) {
8687       {
8688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8689       };
8690     }
8691   }
8692 }
8693
8694
8695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
8696   void * jresult ;
8697   Dali::Radian *result = 0 ;
8698
8699   result = (Dali::Radian *)&Dali::ANGLE_360;
8700   jresult = (void *)result;
8701   return jresult;
8702 }
8703
8704
8705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
8706   void * jresult ;
8707   Dali::Radian *result = 0 ;
8708
8709   result = (Dali::Radian *)&Dali::ANGLE_315;
8710   jresult = (void *)result;
8711   return jresult;
8712 }
8713
8714
8715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
8716   void * jresult ;
8717   Dali::Radian *result = 0 ;
8718
8719   result = (Dali::Radian *)&Dali::ANGLE_270;
8720   jresult = (void *)result;
8721   return jresult;
8722 }
8723
8724
8725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
8726   void * jresult ;
8727   Dali::Radian *result = 0 ;
8728
8729   result = (Dali::Radian *)&Dali::ANGLE_225;
8730   jresult = (void *)result;
8731   return jresult;
8732 }
8733
8734
8735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
8736   void * jresult ;
8737   Dali::Radian *result = 0 ;
8738
8739   result = (Dali::Radian *)&Dali::ANGLE_180;
8740   jresult = (void *)result;
8741   return jresult;
8742 }
8743
8744
8745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
8746   void * jresult ;
8747   Dali::Radian *result = 0 ;
8748
8749   result = (Dali::Radian *)&Dali::ANGLE_135;
8750   jresult = (void *)result;
8751   return jresult;
8752 }
8753
8754
8755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
8756   void * jresult ;
8757   Dali::Radian *result = 0 ;
8758
8759   result = (Dali::Radian *)&Dali::ANGLE_120;
8760   jresult = (void *)result;
8761   return jresult;
8762 }
8763
8764
8765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
8766   void * jresult ;
8767   Dali::Radian *result = 0 ;
8768
8769   result = (Dali::Radian *)&Dali::ANGLE_90;
8770   jresult = (void *)result;
8771   return jresult;
8772 }
8773
8774
8775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
8776   void * jresult ;
8777   Dali::Radian *result = 0 ;
8778
8779   result = (Dali::Radian *)&Dali::ANGLE_60;
8780   jresult = (void *)result;
8781   return jresult;
8782 }
8783
8784
8785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
8786   void * jresult ;
8787   Dali::Radian *result = 0 ;
8788
8789   result = (Dali::Radian *)&Dali::ANGLE_45;
8790   jresult = (void *)result;
8791   return jresult;
8792 }
8793
8794
8795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
8796   void * jresult ;
8797   Dali::Radian *result = 0 ;
8798
8799   result = (Dali::Radian *)&Dali::ANGLE_30;
8800   jresult = (void *)result;
8801   return jresult;
8802 }
8803
8804
8805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
8806   void * jresult ;
8807   Dali::Radian *result = 0 ;
8808
8809   result = (Dali::Radian *)&Dali::ANGLE_0;
8810   jresult = (void *)result;
8811   return jresult;
8812 }
8813
8814
8815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
8816   unsigned int jresult ;
8817   Dali::Degree *arg1 = 0 ;
8818   Dali::Degree *arg2 = 0 ;
8819   bool result;
8820
8821   arg1 = (Dali::Degree *)jarg1;
8822   if (!arg1) {
8823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8824     return 0;
8825   }
8826   arg2 = (Dali::Degree *)jarg2;
8827   if (!arg2) {
8828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8829     return 0;
8830   }
8831   {
8832     try {
8833       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8834     } catch (std::out_of_range& e) {
8835       {
8836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8837       };
8838     } catch (std::exception& e) {
8839       {
8840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8841       };
8842     } catch (...) {
8843       {
8844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8845       };
8846     }
8847   }
8848   jresult = result;
8849   return jresult;
8850 }
8851
8852
8853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
8854   unsigned int jresult ;
8855   Dali::Degree *arg1 = 0 ;
8856   Dali::Degree *arg2 = 0 ;
8857   bool result;
8858
8859   arg1 = (Dali::Degree *)jarg1;
8860   if (!arg1) {
8861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8862     return 0;
8863   }
8864   arg2 = (Dali::Degree *)jarg2;
8865   if (!arg2) {
8866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
8867     return 0;
8868   }
8869   {
8870     try {
8871       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
8872     } catch (std::out_of_range& e) {
8873       {
8874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8875       };
8876     } catch (std::exception& e) {
8877       {
8878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8879       };
8880     } catch (...) {
8881       {
8882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8883       };
8884     }
8885   }
8886   jresult = result;
8887   return jresult;
8888 }
8889
8890
8891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
8892   void * jresult ;
8893   Dali::Degree arg1 ;
8894   float arg2 ;
8895   float arg3 ;
8896   Dali::Degree *argp1 ;
8897   Dali::Degree result;
8898
8899   argp1 = (Dali::Degree *)jarg1;
8900   if (!argp1) {
8901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8902     return 0;
8903   }
8904   arg1 = *argp1;
8905   arg2 = (float)jarg2;
8906   arg3 = (float)jarg3;
8907   {
8908     try {
8909       result = Dali::Clamp(arg1,arg2,arg3);
8910     } catch (std::out_of_range& e) {
8911       {
8912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8913       };
8914     } catch (std::exception& e) {
8915       {
8916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8917       };
8918     } catch (...) {
8919       {
8920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8921       };
8922     }
8923   }
8924   jresult = new Dali::Degree((const Dali::Degree &)result);
8925   return jresult;
8926 }
8927
8928
8929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
8930   void * jresult ;
8931   Dali::Radian *result = 0 ;
8932
8933   {
8934     try {
8935       result = (Dali::Radian *)new Dali::Radian();
8936     } catch (std::out_of_range& e) {
8937       {
8938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8939       };
8940     } catch (std::exception& e) {
8941       {
8942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8943       };
8944     } catch (...) {
8945       {
8946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8947       };
8948     }
8949   }
8950   jresult = (void *)result;
8951   return jresult;
8952 }
8953
8954
8955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
8956   void * jresult ;
8957   float arg1 ;
8958   Dali::Radian *result = 0 ;
8959
8960   arg1 = (float)jarg1;
8961   {
8962     try {
8963       result = (Dali::Radian *)new Dali::Radian(arg1);
8964     } catch (std::out_of_range& e) {
8965       {
8966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8967       };
8968     } catch (std::exception& e) {
8969       {
8970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8971       };
8972     } catch (...) {
8973       {
8974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8975       };
8976     }
8977   }
8978   jresult = (void *)result;
8979   return jresult;
8980 }
8981
8982
8983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
8984   void * jresult ;
8985   Dali::Degree arg1 ;
8986   Dali::Degree *argp1 ;
8987   Dali::Radian *result = 0 ;
8988
8989   argp1 = (Dali::Degree *)jarg1;
8990   if (!argp1) {
8991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
8992     return 0;
8993   }
8994   arg1 = *argp1;
8995   {
8996     try {
8997       result = (Dali::Radian *)new Dali::Radian(arg1);
8998     } catch (std::out_of_range& e) {
8999       {
9000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9001       };
9002     } catch (std::exception& e) {
9003       {
9004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9005       };
9006     } catch (...) {
9007       {
9008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9009       };
9010     }
9011   }
9012   jresult = (void *)result;
9013   return jresult;
9014 }
9015
9016
9017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9018   void * jresult ;
9019   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9020   float arg2 ;
9021   Dali::Radian *result = 0 ;
9022
9023   arg1 = (Dali::Radian *)jarg1;
9024   arg2 = (float)jarg2;
9025   {
9026     try {
9027       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9028     } catch (std::out_of_range& e) {
9029       {
9030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9031       };
9032     } catch (std::exception& e) {
9033       {
9034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9035       };
9036     } catch (...) {
9037       {
9038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9039       };
9040     }
9041   }
9042   jresult = (void *)result;
9043   return jresult;
9044 }
9045
9046
9047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
9048   void * jresult ;
9049   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9050   Dali::Degree arg2 ;
9051   Dali::Degree *argp2 ;
9052   Dali::Radian *result = 0 ;
9053
9054   arg1 = (Dali::Radian *)jarg1;
9055   argp2 = (Dali::Degree *)jarg2;
9056   if (!argp2) {
9057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9058     return 0;
9059   }
9060   arg2 = *argp2;
9061   {
9062     try {
9063       result = (Dali::Radian *) &(arg1)->operator =(arg2);
9064     } catch (std::out_of_range& e) {
9065       {
9066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9067       };
9068     } catch (std::exception& e) {
9069       {
9070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9071       };
9072     } catch (...) {
9073       {
9074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9075       };
9076     }
9077   }
9078   jresult = (void *)result;
9079   return jresult;
9080 }
9081
9082
9083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
9084   float jresult ;
9085   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9086   float result;
9087
9088   arg1 = (Dali::Radian *)jarg1;
9089   {
9090     try {
9091       result = (float)((Dali::Radian const *)arg1)->operator float();
9092     } catch (std::out_of_range& e) {
9093       {
9094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9095       };
9096     } catch (std::exception& e) {
9097       {
9098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9099       };
9100     } catch (...) {
9101       {
9102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9103       };
9104     }
9105   }
9106   jresult = result;
9107   return jresult;
9108 }
9109
9110
9111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
9112   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9113   float arg2 ;
9114
9115   arg1 = (Dali::Radian *)jarg1;
9116   arg2 = (float)jarg2;
9117   if (arg1) (arg1)->radian = arg2;
9118 }
9119
9120
9121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
9122   float jresult ;
9123   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9124   float result;
9125
9126   arg1 = (Dali::Radian *)jarg1;
9127   result = (float) ((arg1)->radian);
9128   jresult = result;
9129   return jresult;
9130 }
9131
9132
9133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
9134   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
9135
9136   arg1 = (Dali::Radian *)jarg1;
9137   {
9138     try {
9139       delete arg1;
9140     } catch (std::out_of_range& e) {
9141       {
9142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9143       };
9144     } catch (std::exception& e) {
9145       {
9146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9147       };
9148     } catch (...) {
9149       {
9150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9151       };
9152     }
9153   }
9154 }
9155
9156
9157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
9158   unsigned int jresult ;
9159   Dali::Radian arg1 ;
9160   Dali::Radian arg2 ;
9161   Dali::Radian *argp1 ;
9162   Dali::Radian *argp2 ;
9163   bool result;
9164
9165   argp1 = (Dali::Radian *)jarg1;
9166   if (!argp1) {
9167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9168     return 0;
9169   }
9170   arg1 = *argp1;
9171   argp2 = (Dali::Radian *)jarg2;
9172   if (!argp2) {
9173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9174     return 0;
9175   }
9176   arg2 = *argp2;
9177   {
9178     try {
9179       result = (bool)Dali::operator ==(arg1,arg2);
9180     } catch (std::out_of_range& e) {
9181       {
9182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9183       };
9184     } catch (std::exception& e) {
9185       {
9186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9187       };
9188     } catch (...) {
9189       {
9190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9191       };
9192     }
9193   }
9194   jresult = result;
9195   return jresult;
9196 }
9197
9198
9199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
9200   unsigned int jresult ;
9201   Dali::Radian arg1 ;
9202   Dali::Radian arg2 ;
9203   Dali::Radian *argp1 ;
9204   Dali::Radian *argp2 ;
9205   bool result;
9206
9207   argp1 = (Dali::Radian *)jarg1;
9208   if (!argp1) {
9209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9210     return 0;
9211   }
9212   arg1 = *argp1;
9213   argp2 = (Dali::Radian *)jarg2;
9214   if (!argp2) {
9215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9216     return 0;
9217   }
9218   arg2 = *argp2;
9219   {
9220     try {
9221       result = (bool)Dali::operator !=(arg1,arg2);
9222     } catch (std::out_of_range& e) {
9223       {
9224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9225       };
9226     } catch (std::exception& e) {
9227       {
9228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9229       };
9230     } catch (...) {
9231       {
9232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9233       };
9234     }
9235   }
9236   jresult = result;
9237   return jresult;
9238 }
9239
9240
9241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
9242   unsigned int jresult ;
9243   Dali::Radian arg1 ;
9244   Dali::Degree arg2 ;
9245   Dali::Radian *argp1 ;
9246   Dali::Degree *argp2 ;
9247   bool result;
9248
9249   argp1 = (Dali::Radian *)jarg1;
9250   if (!argp1) {
9251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9252     return 0;
9253   }
9254   arg1 = *argp1;
9255   argp2 = (Dali::Degree *)jarg2;
9256   if (!argp2) {
9257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9258     return 0;
9259   }
9260   arg2 = *argp2;
9261   {
9262     try {
9263       result = (bool)Dali::operator ==(arg1,arg2);
9264     } catch (std::out_of_range& e) {
9265       {
9266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9267       };
9268     } catch (std::exception& e) {
9269       {
9270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9271       };
9272     } catch (...) {
9273       {
9274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9275       };
9276     }
9277   }
9278   jresult = result;
9279   return jresult;
9280 }
9281
9282
9283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
9284   unsigned int jresult ;
9285   Dali::Radian arg1 ;
9286   Dali::Degree arg2 ;
9287   Dali::Radian *argp1 ;
9288   Dali::Degree *argp2 ;
9289   bool result;
9290
9291   argp1 = (Dali::Radian *)jarg1;
9292   if (!argp1) {
9293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9294     return 0;
9295   }
9296   arg1 = *argp1;
9297   argp2 = (Dali::Degree *)jarg2;
9298   if (!argp2) {
9299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9300     return 0;
9301   }
9302   arg2 = *argp2;
9303   {
9304     try {
9305       result = (bool)Dali::operator !=(arg1,arg2);
9306     } catch (std::out_of_range& e) {
9307       {
9308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9309       };
9310     } catch (std::exception& e) {
9311       {
9312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9313       };
9314     } catch (...) {
9315       {
9316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9317       };
9318     }
9319   }
9320   jresult = result;
9321   return jresult;
9322 }
9323
9324
9325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
9326   unsigned int jresult ;
9327   Dali::Degree arg1 ;
9328   Dali::Radian arg2 ;
9329   Dali::Degree *argp1 ;
9330   Dali::Radian *argp2 ;
9331   bool result;
9332
9333   argp1 = (Dali::Degree *)jarg1;
9334   if (!argp1) {
9335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9336     return 0;
9337   }
9338   arg1 = *argp1;
9339   argp2 = (Dali::Radian *)jarg2;
9340   if (!argp2) {
9341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9342     return 0;
9343   }
9344   arg2 = *argp2;
9345   {
9346     try {
9347       result = (bool)Dali::operator ==(arg1,arg2);
9348     } catch (std::out_of_range& e) {
9349       {
9350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9351       };
9352     } catch (std::exception& e) {
9353       {
9354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9355       };
9356     } catch (...) {
9357       {
9358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9359       };
9360     }
9361   }
9362   jresult = result;
9363   return jresult;
9364 }
9365
9366
9367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
9368   unsigned int jresult ;
9369   Dali::Degree arg1 ;
9370   Dali::Radian arg2 ;
9371   Dali::Degree *argp1 ;
9372   Dali::Radian *argp2 ;
9373   bool result;
9374
9375   argp1 = (Dali::Degree *)jarg1;
9376   if (!argp1) {
9377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9378     return 0;
9379   }
9380   arg1 = *argp1;
9381   argp2 = (Dali::Radian *)jarg2;
9382   if (!argp2) {
9383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9384     return 0;
9385   }
9386   arg2 = *argp2;
9387   {
9388     try {
9389       result = (bool)Dali::operator !=(arg1,arg2);
9390     } catch (std::out_of_range& e) {
9391       {
9392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9393       };
9394     } catch (std::exception& e) {
9395       {
9396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9397       };
9398     } catch (...) {
9399       {
9400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9401       };
9402     }
9403   }
9404   jresult = result;
9405   return jresult;
9406 }
9407
9408
9409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
9410   unsigned int jresult ;
9411   Dali::Radian arg1 ;
9412   Dali::Radian arg2 ;
9413   Dali::Radian *argp1 ;
9414   Dali::Radian *argp2 ;
9415   bool result;
9416
9417   argp1 = (Dali::Radian *)jarg1;
9418   if (!argp1) {
9419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9420     return 0;
9421   }
9422   arg1 = *argp1;
9423   argp2 = (Dali::Radian *)jarg2;
9424   if (!argp2) {
9425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9426     return 0;
9427   }
9428   arg2 = *argp2;
9429   {
9430     try {
9431       result = (bool)Dali::operator >(arg1,arg2);
9432     } catch (std::out_of_range& e) {
9433       {
9434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9435       };
9436     } catch (std::exception& e) {
9437       {
9438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9439       };
9440     } catch (...) {
9441       {
9442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9443       };
9444     }
9445   }
9446   jresult = result;
9447   return jresult;
9448 }
9449
9450
9451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
9452   unsigned int jresult ;
9453   Dali::Radian arg1 ;
9454   Dali::Degree arg2 ;
9455   Dali::Radian *argp1 ;
9456   Dali::Degree *argp2 ;
9457   bool result;
9458
9459   argp1 = (Dali::Radian *)jarg1;
9460   if (!argp1) {
9461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9462     return 0;
9463   }
9464   arg1 = *argp1;
9465   argp2 = (Dali::Degree *)jarg2;
9466   if (!argp2) {
9467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9468     return 0;
9469   }
9470   arg2 = *argp2;
9471   {
9472     try {
9473       result = (bool)Dali::operator >(arg1,arg2);
9474     } catch (std::out_of_range& e) {
9475       {
9476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9477       };
9478     } catch (std::exception& e) {
9479       {
9480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9481       };
9482     } catch (...) {
9483       {
9484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9485       };
9486     }
9487   }
9488   jresult = result;
9489   return jresult;
9490 }
9491
9492
9493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
9494   unsigned int jresult ;
9495   Dali::Degree arg1 ;
9496   Dali::Radian arg2 ;
9497   Dali::Degree *argp1 ;
9498   Dali::Radian *argp2 ;
9499   bool result;
9500
9501   argp1 = (Dali::Degree *)jarg1;
9502   if (!argp1) {
9503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9504     return 0;
9505   }
9506   arg1 = *argp1;
9507   argp2 = (Dali::Radian *)jarg2;
9508   if (!argp2) {
9509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9510     return 0;
9511   }
9512   arg2 = *argp2;
9513   {
9514     try {
9515       result = (bool)Dali::operator >(arg1,arg2);
9516     } catch (std::out_of_range& e) {
9517       {
9518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9519       };
9520     } catch (std::exception& e) {
9521       {
9522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9523       };
9524     } catch (...) {
9525       {
9526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9527       };
9528     }
9529   }
9530   jresult = result;
9531   return jresult;
9532 }
9533
9534
9535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
9536   unsigned int jresult ;
9537   Dali::Radian arg1 ;
9538   Dali::Radian arg2 ;
9539   Dali::Radian *argp1 ;
9540   Dali::Radian *argp2 ;
9541   bool result;
9542
9543   argp1 = (Dali::Radian *)jarg1;
9544   if (!argp1) {
9545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9546     return 0;
9547   }
9548   arg1 = *argp1;
9549   argp2 = (Dali::Radian *)jarg2;
9550   if (!argp2) {
9551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9552     return 0;
9553   }
9554   arg2 = *argp2;
9555   {
9556     try {
9557       result = (bool)Dali::operator <(arg1,arg2);
9558     } catch (std::out_of_range& e) {
9559       {
9560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9561       };
9562     } catch (std::exception& e) {
9563       {
9564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9565       };
9566     } catch (...) {
9567       {
9568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9569       };
9570     }
9571   }
9572   jresult = result;
9573   return jresult;
9574 }
9575
9576
9577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
9578   unsigned int jresult ;
9579   Dali::Radian arg1 ;
9580   Dali::Degree arg2 ;
9581   Dali::Radian *argp1 ;
9582   Dali::Degree *argp2 ;
9583   bool result;
9584
9585   argp1 = (Dali::Radian *)jarg1;
9586   if (!argp1) {
9587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9588     return 0;
9589   }
9590   arg1 = *argp1;
9591   argp2 = (Dali::Degree *)jarg2;
9592   if (!argp2) {
9593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9594     return 0;
9595   }
9596   arg2 = *argp2;
9597   {
9598     try {
9599       result = (bool)Dali::operator <(arg1,arg2);
9600     } catch (std::out_of_range& e) {
9601       {
9602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9603       };
9604     } catch (std::exception& e) {
9605       {
9606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9607       };
9608     } catch (...) {
9609       {
9610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9611       };
9612     }
9613   }
9614   jresult = result;
9615   return jresult;
9616 }
9617
9618
9619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
9620   unsigned int jresult ;
9621   Dali::Degree arg1 ;
9622   Dali::Radian arg2 ;
9623   Dali::Degree *argp1 ;
9624   Dali::Radian *argp2 ;
9625   bool result;
9626
9627   argp1 = (Dali::Degree *)jarg1;
9628   if (!argp1) {
9629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9630     return 0;
9631   }
9632   arg1 = *argp1;
9633   argp2 = (Dali::Radian *)jarg2;
9634   if (!argp2) {
9635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9636     return 0;
9637   }
9638   arg2 = *argp2;
9639   {
9640     try {
9641       result = (bool)Dali::operator <(arg1,arg2);
9642     } catch (std::out_of_range& e) {
9643       {
9644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9645       };
9646     } catch (std::exception& e) {
9647       {
9648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9649       };
9650     } catch (...) {
9651       {
9652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9653       };
9654     }
9655   }
9656   jresult = result;
9657   return jresult;
9658 }
9659
9660
9661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
9662   void * jresult ;
9663   Dali::Radian arg1 ;
9664   float arg2 ;
9665   Dali::Radian *argp1 ;
9666   Dali::Radian result;
9667
9668   argp1 = (Dali::Radian *)jarg1;
9669   if (!argp1) {
9670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9671     return 0;
9672   }
9673   arg1 = *argp1;
9674   arg2 = (float)jarg2;
9675   {
9676     try {
9677       result = Dali::operator *(arg1,arg2);
9678     } catch (std::out_of_range& e) {
9679       {
9680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9681       };
9682     } catch (std::exception& e) {
9683       {
9684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9685       };
9686     } catch (...) {
9687       {
9688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9689       };
9690     }
9691   }
9692   jresult = new Dali::Radian((const Dali::Radian &)result);
9693   return jresult;
9694 }
9695
9696
9697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
9698   void * jresult ;
9699   Dali::Radian arg1 ;
9700   Dali::Radian *argp1 ;
9701   Dali::Radian result;
9702
9703   argp1 = (Dali::Radian *)jarg1;
9704   if (!argp1) {
9705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9706     return 0;
9707   }
9708   arg1 = *argp1;
9709   {
9710     try {
9711       result = Dali::operator -(arg1);
9712     } catch (std::out_of_range& e) {
9713       {
9714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9715       };
9716     } catch (std::exception& e) {
9717       {
9718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9719       };
9720     } catch (...) {
9721       {
9722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9723       };
9724     }
9725   }
9726   jresult = new Dali::Radian((const Dali::Radian &)result);
9727   return jresult;
9728 }
9729
9730
9731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
9732   void * jresult ;
9733   Dali::Radian arg1 ;
9734   float arg2 ;
9735   float arg3 ;
9736   Dali::Radian *argp1 ;
9737   Dali::Radian result;
9738
9739   argp1 = (Dali::Radian *)jarg1;
9740   if (!argp1) {
9741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9742     return 0;
9743   }
9744   arg1 = *argp1;
9745   arg2 = (float)jarg2;
9746   arg3 = (float)jarg3;
9747   {
9748     try {
9749       result = Dali::Clamp(arg1,arg2,arg3);
9750     } catch (std::out_of_range& e) {
9751       {
9752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9753       };
9754     } catch (std::exception& e) {
9755       {
9756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9757       };
9758     } catch (...) {
9759       {
9760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9761       };
9762     }
9763   }
9764   jresult = new Dali::Radian((const Dali::Radian &)result);
9765   return jresult;
9766 }
9767
9768
9769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
9770   void * jresult ;
9771   Dali::Quaternion *result = 0 ;
9772
9773   {
9774     try {
9775       result = (Dali::Quaternion *)new Dali::Quaternion();
9776     } catch (std::out_of_range& e) {
9777       {
9778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9779       };
9780     } catch (std::exception& e) {
9781       {
9782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9783       };
9784     } catch (...) {
9785       {
9786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9787       };
9788     }
9789   }
9790   jresult = (void *)result;
9791   return jresult;
9792 }
9793
9794
9795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
9796   void * jresult ;
9797   Dali::Radian arg1 ;
9798   Dali::Vector3 *arg2 = 0 ;
9799   Dali::Radian *argp1 ;
9800   Dali::Quaternion *result = 0 ;
9801
9802   argp1 = (Dali::Radian *)jarg1;
9803   if (!argp1) {
9804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9805     return 0;
9806   }
9807   arg1 = *argp1;
9808   arg2 = (Dali::Vector3 *)jarg2;
9809   if (!arg2) {
9810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
9811     return 0;
9812   }
9813   {
9814     try {
9815       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
9816     } catch (std::out_of_range& e) {
9817       {
9818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9819       };
9820     } catch (std::exception& e) {
9821       {
9822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9823       };
9824     } catch (...) {
9825       {
9826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9827       };
9828     }
9829   }
9830   jresult = (void *)result;
9831   return jresult;
9832 }
9833
9834
9835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
9836   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9837
9838   arg1 = (Dali::Quaternion *)jarg1;
9839   {
9840     try {
9841       delete arg1;
9842     } catch (std::out_of_range& e) {
9843       {
9844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9845       };
9846     } catch (std::exception& e) {
9847       {
9848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9849       };
9850     } catch (...) {
9851       {
9852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9853       };
9854     }
9855   }
9856 }
9857
9858
9859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
9860   void * jresult ;
9861   Dali::Quaternion *result = 0 ;
9862
9863   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
9864   jresult = (void *)result;
9865   return jresult;
9866 }
9867
9868
9869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
9870   unsigned int jresult ;
9871   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9872   bool result;
9873
9874   arg1 = (Dali::Quaternion *)jarg1;
9875   {
9876     try {
9877       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
9878     } catch (std::out_of_range& e) {
9879       {
9880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9881       };
9882     } catch (std::exception& e) {
9883       {
9884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9885       };
9886     } catch (...) {
9887       {
9888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9889       };
9890     }
9891   }
9892   jresult = result;
9893   return jresult;
9894 }
9895
9896
9897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
9898   unsigned int jresult ;
9899   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9900   Dali::Vector3 *arg2 = 0 ;
9901   Dali::Radian *arg3 = 0 ;
9902   bool result;
9903
9904   arg1 = (Dali::Quaternion *)jarg1;
9905   arg2 = (Dali::Vector3 *)jarg2;
9906   if (!arg2) {
9907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
9908     return 0;
9909   }
9910   arg3 = (Dali::Radian *)jarg3;
9911   if (!arg3) {
9912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
9913     return 0;
9914   }
9915   {
9916     try {
9917       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
9918     } catch (std::out_of_range& e) {
9919       {
9920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9921       };
9922     } catch (std::exception& e) {
9923       {
9924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9925       };
9926     } catch (...) {
9927       {
9928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9929       };
9930     }
9931   }
9932   jresult = result;
9933   return jresult;
9934 }
9935
9936
9937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
9938   void * jresult ;
9939   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9940   Dali::Quaternion *arg2 = 0 ;
9941   Dali::Quaternion result;
9942
9943   arg1 = (Dali::Quaternion *)jarg1;
9944   arg2 = (Dali::Quaternion *)jarg2;
9945   if (!arg2) {
9946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9947     return 0;
9948   }
9949   {
9950     try {
9951       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
9952     } catch (std::out_of_range& e) {
9953       {
9954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9955       };
9956     } catch (std::exception& e) {
9957       {
9958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9959       };
9960     } catch (...) {
9961       {
9962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9963       };
9964     }
9965   }
9966   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
9967   return jresult;
9968 }
9969
9970
9971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
9972   void * jresult ;
9973   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
9974   Dali::Quaternion *arg2 = 0 ;
9975   Dali::Quaternion result;
9976
9977   arg1 = (Dali::Quaternion *)jarg1;
9978   arg2 = (Dali::Quaternion *)jarg2;
9979   if (!arg2) {
9980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
9981     return 0;
9982   }
9983   {
9984     try {
9985       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
9986     } catch (std::out_of_range& e) {
9987       {
9988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9989       };
9990     } catch (std::exception& e) {
9991       {
9992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9993       };
9994     } catch (...) {
9995       {
9996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9997       };
9998     }
9999   }
10000   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10001   return jresult;
10002 }
10003
10004
10005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
10006   void * jresult ;
10007   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10008   Dali::Quaternion *arg2 = 0 ;
10009   Dali::Quaternion result;
10010
10011   arg1 = (Dali::Quaternion *)jarg1;
10012   arg2 = (Dali::Quaternion *)jarg2;
10013   if (!arg2) {
10014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10015     return 0;
10016   }
10017   {
10018     try {
10019       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
10020     } catch (std::out_of_range& e) {
10021       {
10022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10023       };
10024     } catch (std::exception& e) {
10025       {
10026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10027       };
10028     } catch (...) {
10029       {
10030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10031       };
10032     }
10033   }
10034   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10035   return jresult;
10036 }
10037
10038
10039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
10040   void * jresult ;
10041   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10042   Dali::Vector3 *arg2 = 0 ;
10043   Dali::Vector3 result;
10044
10045   arg1 = (Dali::Quaternion *)jarg1;
10046   arg2 = (Dali::Vector3 *)jarg2;
10047   if (!arg2) {
10048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10049     return 0;
10050   }
10051   {
10052     try {
10053       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
10054     } catch (std::out_of_range& e) {
10055       {
10056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10057       };
10058     } catch (std::exception& e) {
10059       {
10060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10061       };
10062     } catch (...) {
10063       {
10064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10065       };
10066     }
10067   }
10068   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
10069   return jresult;
10070 }
10071
10072
10073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
10074   void * jresult ;
10075   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10076   Dali::Quaternion *arg2 = 0 ;
10077   Dali::Quaternion result;
10078
10079   arg1 = (Dali::Quaternion *)jarg1;
10080   arg2 = (Dali::Quaternion *)jarg2;
10081   if (!arg2) {
10082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10083     return 0;
10084   }
10085   {
10086     try {
10087       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
10088     } catch (std::out_of_range& e) {
10089       {
10090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10091       };
10092     } catch (std::exception& e) {
10093       {
10094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10095       };
10096     } catch (...) {
10097       {
10098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10099       };
10100     }
10101   }
10102   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10103   return jresult;
10104 }
10105
10106
10107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
10108   void * jresult ;
10109   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10110   float arg2 ;
10111   Dali::Quaternion result;
10112
10113   arg1 = (Dali::Quaternion *)jarg1;
10114   arg2 = (float)jarg2;
10115   {
10116     try {
10117       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
10118     } catch (std::out_of_range& e) {
10119       {
10120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10121       };
10122     } catch (std::exception& e) {
10123       {
10124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10125       };
10126     } catch (...) {
10127       {
10128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10129       };
10130     }
10131   }
10132   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10133   return jresult;
10134 }
10135
10136
10137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
10138   void * jresult ;
10139   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10140   float arg2 ;
10141   Dali::Quaternion result;
10142
10143   arg1 = (Dali::Quaternion *)jarg1;
10144   arg2 = (float)jarg2;
10145   {
10146     try {
10147       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
10148     } catch (std::out_of_range& e) {
10149       {
10150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10151       };
10152     } catch (std::exception& e) {
10153       {
10154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10155       };
10156     } catch (...) {
10157       {
10158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10159       };
10160     }
10161   }
10162   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10163   return jresult;
10164 }
10165
10166
10167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
10168   void * jresult ;
10169   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10170   Dali::Quaternion result;
10171
10172   arg1 = (Dali::Quaternion *)jarg1;
10173   {
10174     try {
10175       result = ((Dali::Quaternion const *)arg1)->operator -();
10176     } catch (std::out_of_range& e) {
10177       {
10178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10179       };
10180     } catch (std::exception& e) {
10181       {
10182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10183       };
10184     } catch (...) {
10185       {
10186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10187       };
10188     }
10189   }
10190   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10191   return jresult;
10192 }
10193
10194
10195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
10196   void * jresult ;
10197   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10198   Dali::Quaternion *arg2 = 0 ;
10199   Dali::Quaternion *result = 0 ;
10200
10201   arg1 = (Dali::Quaternion *)jarg1;
10202   arg2 = (Dali::Quaternion *)jarg2;
10203   if (!arg2) {
10204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10205     return 0;
10206   }
10207   {
10208     try {
10209       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
10210     } catch (std::out_of_range& e) {
10211       {
10212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10213       };
10214     } catch (std::exception& e) {
10215       {
10216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10217       };
10218     } catch (...) {
10219       {
10220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10221       };
10222     }
10223   }
10224   jresult = (void *)result;
10225   return jresult;
10226 }
10227
10228
10229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
10230   void * jresult ;
10231   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10232   Dali::Quaternion *arg2 = 0 ;
10233   Dali::Quaternion *result = 0 ;
10234
10235   arg1 = (Dali::Quaternion *)jarg1;
10236   arg2 = (Dali::Quaternion *)jarg2;
10237   if (!arg2) {
10238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10239     return 0;
10240   }
10241   {
10242     try {
10243       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
10244     } catch (std::out_of_range& e) {
10245       {
10246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10247       };
10248     } catch (std::exception& e) {
10249       {
10250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10251       };
10252     } catch (...) {
10253       {
10254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10255       };
10256     }
10257   }
10258   jresult = (void *)result;
10259   return jresult;
10260 }
10261
10262
10263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
10264   void * jresult ;
10265   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10266   Dali::Quaternion *arg2 = 0 ;
10267   Dali::Quaternion *result = 0 ;
10268
10269   arg1 = (Dali::Quaternion *)jarg1;
10270   arg2 = (Dali::Quaternion *)jarg2;
10271   if (!arg2) {
10272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10273     return 0;
10274   }
10275   {
10276     try {
10277       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
10278     } catch (std::out_of_range& e) {
10279       {
10280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10281       };
10282     } catch (std::exception& e) {
10283       {
10284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10285       };
10286     } catch (...) {
10287       {
10288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10289       };
10290     }
10291   }
10292   jresult = (void *)result;
10293   return jresult;
10294 }
10295
10296
10297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
10298   void * jresult ;
10299   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10300   float arg2 ;
10301   Dali::Quaternion *result = 0 ;
10302
10303   arg1 = (Dali::Quaternion *)jarg1;
10304   arg2 = (float)jarg2;
10305   {
10306     try {
10307       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
10308     } catch (std::out_of_range& e) {
10309       {
10310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10311       };
10312     } catch (std::exception& e) {
10313       {
10314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10315       };
10316     } catch (...) {
10317       {
10318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10319       };
10320     }
10321   }
10322   jresult = (void *)result;
10323   return jresult;
10324 }
10325
10326
10327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
10328   void * jresult ;
10329   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10330   float arg2 ;
10331   Dali::Quaternion *result = 0 ;
10332
10333   arg1 = (Dali::Quaternion *)jarg1;
10334   arg2 = (float)jarg2;
10335   {
10336     try {
10337       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
10338     } catch (std::out_of_range& e) {
10339       {
10340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10341       };
10342     } catch (std::exception& e) {
10343       {
10344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10345       };
10346     } catch (...) {
10347       {
10348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10349       };
10350     }
10351   }
10352   jresult = (void *)result;
10353   return jresult;
10354 }
10355
10356
10357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
10358   unsigned int jresult ;
10359   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10360   Dali::Quaternion *arg2 = 0 ;
10361   bool result;
10362
10363   arg1 = (Dali::Quaternion *)jarg1;
10364   arg2 = (Dali::Quaternion *)jarg2;
10365   if (!arg2) {
10366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10367     return 0;
10368   }
10369   {
10370     try {
10371       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
10372     } catch (std::out_of_range& e) {
10373       {
10374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10375       };
10376     } catch (std::exception& e) {
10377       {
10378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10379       };
10380     } catch (...) {
10381       {
10382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10383       };
10384     }
10385   }
10386   jresult = result;
10387   return jresult;
10388 }
10389
10390
10391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
10392   unsigned int jresult ;
10393   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10394   Dali::Quaternion *arg2 = 0 ;
10395   bool result;
10396
10397   arg1 = (Dali::Quaternion *)jarg1;
10398   arg2 = (Dali::Quaternion *)jarg2;
10399   if (!arg2) {
10400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10401     return 0;
10402   }
10403   {
10404     try {
10405       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
10406     } catch (std::out_of_range& e) {
10407       {
10408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10409       };
10410     } catch (std::exception& e) {
10411       {
10412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10413       };
10414     } catch (...) {
10415       {
10416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10417       };
10418     }
10419   }
10420   jresult = result;
10421   return jresult;
10422 }
10423
10424
10425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
10426   float jresult ;
10427   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10428   float result;
10429
10430   arg1 = (Dali::Quaternion *)jarg1;
10431   {
10432     try {
10433       result = (float)((Dali::Quaternion const *)arg1)->Length();
10434     } catch (std::out_of_range& e) {
10435       {
10436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10437       };
10438     } catch (std::exception& e) {
10439       {
10440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10441       };
10442     } catch (...) {
10443       {
10444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10445       };
10446     }
10447   }
10448   jresult = result;
10449   return jresult;
10450 }
10451
10452
10453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
10454   float jresult ;
10455   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10456   float result;
10457
10458   arg1 = (Dali::Quaternion *)jarg1;
10459   {
10460     try {
10461       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
10462     } catch (std::out_of_range& e) {
10463       {
10464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10465       };
10466     } catch (std::exception& e) {
10467       {
10468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10469       };
10470     } catch (...) {
10471       {
10472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10473       };
10474     }
10475   }
10476   jresult = result;
10477   return jresult;
10478 }
10479
10480
10481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
10482   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10483
10484   arg1 = (Dali::Quaternion *)jarg1;
10485   {
10486     try {
10487       (arg1)->Normalize();
10488     } catch (std::out_of_range& e) {
10489       {
10490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10491       };
10492     } catch (std::exception& e) {
10493       {
10494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10495       };
10496     } catch (...) {
10497       {
10498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10499       };
10500     }
10501   }
10502 }
10503
10504
10505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
10506   void * jresult ;
10507   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10508   Dali::Quaternion result;
10509
10510   arg1 = (Dali::Quaternion *)jarg1;
10511   {
10512     try {
10513       result = ((Dali::Quaternion const *)arg1)->Normalized();
10514     } catch (std::out_of_range& e) {
10515       {
10516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (std::exception& e) {
10519       {
10520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10521       };
10522     } catch (...) {
10523       {
10524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10525       };
10526     }
10527   }
10528   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10529   return jresult;
10530 }
10531
10532
10533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
10534   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10535
10536   arg1 = (Dali::Quaternion *)jarg1;
10537   {
10538     try {
10539       (arg1)->Conjugate();
10540     } catch (std::out_of_range& e) {
10541       {
10542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10543       };
10544     } catch (std::exception& e) {
10545       {
10546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10547       };
10548     } catch (...) {
10549       {
10550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10551       };
10552     }
10553   }
10554 }
10555
10556
10557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
10558   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10559
10560   arg1 = (Dali::Quaternion *)jarg1;
10561   {
10562     try {
10563       (arg1)->Invert();
10564     } catch (std::out_of_range& e) {
10565       {
10566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10567       };
10568     } catch (std::exception& e) {
10569       {
10570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10571       };
10572     } catch (...) {
10573       {
10574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10575       };
10576     }
10577   }
10578 }
10579
10580
10581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
10582   void * jresult ;
10583   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10584   Dali::Quaternion result;
10585
10586   arg1 = (Dali::Quaternion *)jarg1;
10587   {
10588     try {
10589       result = ((Dali::Quaternion const *)arg1)->Log();
10590     } catch (std::out_of_range& e) {
10591       {
10592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10593       };
10594     } catch (std::exception& e) {
10595       {
10596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10597       };
10598     } catch (...) {
10599       {
10600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10601       };
10602     }
10603   }
10604   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10605   return jresult;
10606 }
10607
10608
10609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
10610   void * jresult ;
10611   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10612   Dali::Quaternion result;
10613
10614   arg1 = (Dali::Quaternion *)jarg1;
10615   {
10616     try {
10617       result = ((Dali::Quaternion const *)arg1)->Exp();
10618     } catch (std::out_of_range& e) {
10619       {
10620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10621       };
10622     } catch (std::exception& e) {
10623       {
10624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10625       };
10626     } catch (...) {
10627       {
10628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10629       };
10630     }
10631   }
10632   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10633   return jresult;
10634 }
10635
10636
10637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
10638   float jresult ;
10639   Dali::Quaternion *arg1 = 0 ;
10640   Dali::Quaternion *arg2 = 0 ;
10641   float result;
10642
10643   arg1 = (Dali::Quaternion *)jarg1;
10644   if (!arg1) {
10645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10646     return 0;
10647   }
10648   arg2 = (Dali::Quaternion *)jarg2;
10649   if (!arg2) {
10650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10651     return 0;
10652   }
10653   {
10654     try {
10655       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10656     } catch (std::out_of_range& e) {
10657       {
10658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10659       };
10660     } catch (std::exception& e) {
10661       {
10662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10663       };
10664     } catch (...) {
10665       {
10666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10667       };
10668     }
10669   }
10670   jresult = result;
10671   return jresult;
10672 }
10673
10674
10675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
10676   void * jresult ;
10677   Dali::Quaternion *arg1 = 0 ;
10678   Dali::Quaternion *arg2 = 0 ;
10679   float arg3 ;
10680   Dali::Quaternion result;
10681
10682   arg1 = (Dali::Quaternion *)jarg1;
10683   if (!arg1) {
10684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10685     return 0;
10686   }
10687   arg2 = (Dali::Quaternion *)jarg2;
10688   if (!arg2) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10690     return 0;
10691   }
10692   arg3 = (float)jarg3;
10693   {
10694     try {
10695       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10696     } catch (std::out_of_range& e) {
10697       {
10698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10699       };
10700     } catch (std::exception& e) {
10701       {
10702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10703       };
10704     } catch (...) {
10705       {
10706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10707       };
10708     }
10709   }
10710   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10711   return jresult;
10712 }
10713
10714
10715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
10716   void * jresult ;
10717   Dali::Quaternion *arg1 = 0 ;
10718   Dali::Quaternion *arg2 = 0 ;
10719   float arg3 ;
10720   Dali::Quaternion result;
10721
10722   arg1 = (Dali::Quaternion *)jarg1;
10723   if (!arg1) {
10724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10725     return 0;
10726   }
10727   arg2 = (Dali::Quaternion *)jarg2;
10728   if (!arg2) {
10729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10730     return 0;
10731   }
10732   arg3 = (float)jarg3;
10733   {
10734     try {
10735       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10736     } catch (std::out_of_range& e) {
10737       {
10738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10739       };
10740     } catch (std::exception& e) {
10741       {
10742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10743       };
10744     } catch (...) {
10745       {
10746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10747       };
10748     }
10749   }
10750   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10751   return jresult;
10752 }
10753
10754
10755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
10756   void * jresult ;
10757   Dali::Quaternion *arg1 = 0 ;
10758   Dali::Quaternion *arg2 = 0 ;
10759   float arg3 ;
10760   Dali::Quaternion result;
10761
10762   arg1 = (Dali::Quaternion *)jarg1;
10763   if (!arg1) {
10764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10765     return 0;
10766   }
10767   arg2 = (Dali::Quaternion *)jarg2;
10768   if (!arg2) {
10769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10770     return 0;
10771   }
10772   arg3 = (float)jarg3;
10773   {
10774     try {
10775       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
10776     } catch (std::out_of_range& e) {
10777       {
10778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10779       };
10780     } catch (std::exception& e) {
10781       {
10782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10783       };
10784     } catch (...) {
10785       {
10786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10787       };
10788     }
10789   }
10790   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10791   return jresult;
10792 }
10793
10794
10795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
10796   void * jresult ;
10797   Dali::Quaternion *arg1 = 0 ;
10798   Dali::Quaternion *arg2 = 0 ;
10799   Dali::Quaternion *arg3 = 0 ;
10800   Dali::Quaternion *arg4 = 0 ;
10801   float arg5 ;
10802   Dali::Quaternion result;
10803
10804   arg1 = (Dali::Quaternion *)jarg1;
10805   if (!arg1) {
10806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10807     return 0;
10808   }
10809   arg2 = (Dali::Quaternion *)jarg2;
10810   if (!arg2) {
10811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10812     return 0;
10813   }
10814   arg3 = (Dali::Quaternion *)jarg3;
10815   if (!arg3) {
10816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10817     return 0;
10818   }
10819   arg4 = (Dali::Quaternion *)jarg4;
10820   if (!arg4) {
10821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10822     return 0;
10823   }
10824   arg5 = (float)jarg5;
10825   {
10826     try {
10827       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
10828     } catch (std::out_of_range& e) {
10829       {
10830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10831       };
10832     } catch (std::exception& e) {
10833       {
10834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10835       };
10836     } catch (...) {
10837       {
10838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10839       };
10840     }
10841   }
10842   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
10843   return jresult;
10844 }
10845
10846
10847 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
10848   float jresult ;
10849   Dali::Quaternion *arg1 = 0 ;
10850   Dali::Quaternion *arg2 = 0 ;
10851   float result;
10852
10853   arg1 = (Dali::Quaternion *)jarg1;
10854   if (!arg1) {
10855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10856     return 0;
10857   }
10858   arg2 = (Dali::Quaternion *)jarg2;
10859   if (!arg2) {
10860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10861     return 0;
10862   }
10863   {
10864     try {
10865       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
10866     } catch (std::out_of_range& e) {
10867       {
10868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10869       };
10870     } catch (std::exception& e) {
10871       {
10872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10873       };
10874     } catch (...) {
10875       {
10876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10877       };
10878     }
10879   }
10880   jresult = result;
10881   return jresult;
10882 }
10883
10884
10885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
10886   void * jresult ;
10887   Dali::Matrix *result = 0 ;
10888
10889   {
10890     try {
10891       result = (Dali::Matrix *)new Dali::Matrix();
10892     } catch (std::out_of_range& e) {
10893       {
10894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10895       };
10896     } catch (std::exception& e) {
10897       {
10898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10899       };
10900     } catch (...) {
10901       {
10902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10903       };
10904     }
10905   }
10906   jresult = (void *)result;
10907   return jresult;
10908 }
10909
10910
10911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
10912   void * jresult ;
10913   bool arg1 ;
10914   Dali::Matrix *result = 0 ;
10915
10916   arg1 = jarg1 ? true : false;
10917   {
10918     try {
10919       result = (Dali::Matrix *)new Dali::Matrix(arg1);
10920     } catch (std::out_of_range& e) {
10921       {
10922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10923       };
10924     } catch (std::exception& e) {
10925       {
10926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10927       };
10928     } catch (...) {
10929       {
10930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10931       };
10932     }
10933   }
10934   jresult = (void *)result;
10935   return jresult;
10936 }
10937
10938
10939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
10940   void * jresult ;
10941   float *arg1 = (float *) 0 ;
10942   Dali::Matrix *result = 0 ;
10943
10944   arg1 = jarg1;
10945   {
10946     try {
10947       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
10948     } catch (std::out_of_range& e) {
10949       {
10950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10951       };
10952     } catch (std::exception& e) {
10953       {
10954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10955       };
10956     } catch (...) {
10957       {
10958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10959       };
10960     }
10961   }
10962   jresult = (void *)result;
10963
10964
10965   return jresult;
10966 }
10967
10968
10969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
10970   void * jresult ;
10971   Dali::Quaternion *arg1 = 0 ;
10972   Dali::Matrix *result = 0 ;
10973
10974   arg1 = (Dali::Quaternion *)jarg1;
10975   if (!arg1) {
10976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
10977     return 0;
10978   }
10979   {
10980     try {
10981       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
10982     } catch (std::out_of_range& e) {
10983       {
10984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10985       };
10986     } catch (std::exception& e) {
10987       {
10988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10989       };
10990     } catch (...) {
10991       {
10992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10993       };
10994     }
10995   }
10996   jresult = (void *)result;
10997   return jresult;
10998 }
10999
11000
11001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
11002   void * jresult ;
11003   Dali::Matrix *arg1 = 0 ;
11004   Dali::Matrix *result = 0 ;
11005
11006   arg1 = (Dali::Matrix *)jarg1;
11007   if (!arg1) {
11008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11009     return 0;
11010   }
11011   {
11012     try {
11013       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
11014     } catch (std::out_of_range& e) {
11015       {
11016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11017       };
11018     } catch (std::exception& e) {
11019       {
11020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11021       };
11022     } catch (...) {
11023       {
11024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11025       };
11026     }
11027   }
11028   jresult = (void *)result;
11029   return jresult;
11030 }
11031
11032
11033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
11034   void * jresult ;
11035   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11036   Dali::Matrix *arg2 = 0 ;
11037   Dali::Matrix *result = 0 ;
11038
11039   arg1 = (Dali::Matrix *)jarg1;
11040   arg2 = (Dali::Matrix *)jarg2;
11041   if (!arg2) {
11042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11043     return 0;
11044   }
11045   {
11046     try {
11047       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
11048     } catch (std::out_of_range& e) {
11049       {
11050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11051       };
11052     } catch (std::exception& e) {
11053       {
11054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11055       };
11056     } catch (...) {
11057       {
11058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11059       };
11060     }
11061   }
11062   jresult = (void *)result;
11063   return jresult;
11064 }
11065
11066
11067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
11068   void * jresult ;
11069   Dali::Matrix *result = 0 ;
11070
11071   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
11072   jresult = (void *)result;
11073   return jresult;
11074 }
11075
11076
11077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
11078   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11079
11080   arg1 = (Dali::Matrix *)jarg1;
11081   {
11082     try {
11083       (arg1)->SetIdentity();
11084     } catch (std::out_of_range& e) {
11085       {
11086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11087       };
11088     } catch (std::exception& e) {
11089       {
11090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11091       };
11092     } catch (...) {
11093       {
11094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11095       };
11096     }
11097   }
11098 }
11099
11100
11101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
11102   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11103   Dali::Vector3 *arg2 = 0 ;
11104
11105   arg1 = (Dali::Matrix *)jarg1;
11106   arg2 = (Dali::Vector3 *)jarg2;
11107   if (!arg2) {
11108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11109     return ;
11110   }
11111   {
11112     try {
11113       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
11114     } catch (std::out_of_range& e) {
11115       {
11116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11117       };
11118     } catch (std::exception& e) {
11119       {
11120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11121       };
11122     } catch (...) {
11123       {
11124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11125       };
11126     }
11127   }
11128 }
11129
11130
11131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
11132   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11133   Dali::Matrix *arg2 = 0 ;
11134
11135   arg1 = (Dali::Matrix *)jarg1;
11136   arg2 = (Dali::Matrix *)jarg2;
11137   if (!arg2) {
11138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11139     return ;
11140   }
11141   {
11142     try {
11143       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
11144     } catch (std::out_of_range& e) {
11145       {
11146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11147       };
11148     } catch (std::exception& e) {
11149       {
11150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11151       };
11152     } catch (...) {
11153       {
11154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11155       };
11156     }
11157   }
11158 }
11159
11160
11161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
11162   unsigned int jresult ;
11163   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11164   bool result;
11165
11166   arg1 = (Dali::Matrix *)jarg1;
11167   {
11168     try {
11169       result = (bool)(arg1)->Invert();
11170     } catch (std::out_of_range& e) {
11171       {
11172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11173       };
11174     } catch (std::exception& e) {
11175       {
11176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11177       };
11178     } catch (...) {
11179       {
11180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11181       };
11182     }
11183   }
11184   jresult = result;
11185   return jresult;
11186 }
11187
11188
11189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
11190   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11191
11192   arg1 = (Dali::Matrix *)jarg1;
11193   {
11194     try {
11195       (arg1)->Transpose();
11196     } catch (std::out_of_range& e) {
11197       {
11198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11199       };
11200     } catch (std::exception& e) {
11201       {
11202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11203       };
11204     } catch (...) {
11205       {
11206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11207       };
11208     }
11209   }
11210 }
11211
11212
11213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
11214   void * jresult ;
11215   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11216   Dali::Vector3 result;
11217
11218   arg1 = (Dali::Matrix *)jarg1;
11219   {
11220     try {
11221       result = ((Dali::Matrix const *)arg1)->GetXAxis();
11222     } catch (std::out_of_range& e) {
11223       {
11224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11225       };
11226     } catch (std::exception& e) {
11227       {
11228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11229       };
11230     } catch (...) {
11231       {
11232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11233       };
11234     }
11235   }
11236   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11237   return jresult;
11238 }
11239
11240
11241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
11242   void * jresult ;
11243   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11244   Dali::Vector3 result;
11245
11246   arg1 = (Dali::Matrix *)jarg1;
11247   {
11248     try {
11249       result = ((Dali::Matrix const *)arg1)->GetYAxis();
11250     } catch (std::out_of_range& e) {
11251       {
11252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11253       };
11254     } catch (std::exception& e) {
11255       {
11256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11257       };
11258     } catch (...) {
11259       {
11260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11261       };
11262     }
11263   }
11264   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11265   return jresult;
11266 }
11267
11268
11269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
11270   void * jresult ;
11271   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11272   Dali::Vector3 result;
11273
11274   arg1 = (Dali::Matrix *)jarg1;
11275   {
11276     try {
11277       result = ((Dali::Matrix const *)arg1)->GetZAxis();
11278     } catch (std::out_of_range& e) {
11279       {
11280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11281       };
11282     } catch (std::exception& e) {
11283       {
11284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11285       };
11286     } catch (...) {
11287       {
11288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11289       };
11290     }
11291   }
11292   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11293   return jresult;
11294 }
11295
11296
11297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
11298   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11299   Dali::Vector3 *arg2 = 0 ;
11300
11301   arg1 = (Dali::Matrix *)jarg1;
11302   arg2 = (Dali::Vector3 *)jarg2;
11303   if (!arg2) {
11304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11305     return ;
11306   }
11307   {
11308     try {
11309       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
11310     } catch (std::out_of_range& e) {
11311       {
11312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11313       };
11314     } catch (std::exception& e) {
11315       {
11316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11317       };
11318     } catch (...) {
11319       {
11320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11321       };
11322     }
11323   }
11324 }
11325
11326
11327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
11328   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11329   Dali::Vector3 *arg2 = 0 ;
11330
11331   arg1 = (Dali::Matrix *)jarg1;
11332   arg2 = (Dali::Vector3 *)jarg2;
11333   if (!arg2) {
11334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11335     return ;
11336   }
11337   {
11338     try {
11339       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
11340     } catch (std::out_of_range& e) {
11341       {
11342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11343       };
11344     } catch (std::exception& e) {
11345       {
11346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11347       };
11348     } catch (...) {
11349       {
11350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11351       };
11352     }
11353   }
11354 }
11355
11356
11357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
11358   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11359   Dali::Vector3 *arg2 = 0 ;
11360
11361   arg1 = (Dali::Matrix *)jarg1;
11362   arg2 = (Dali::Vector3 *)jarg2;
11363   if (!arg2) {
11364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11365     return ;
11366   }
11367   {
11368     try {
11369       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
11370     } catch (std::out_of_range& e) {
11371       {
11372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11373       };
11374     } catch (std::exception& e) {
11375       {
11376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11377       };
11378     } catch (...) {
11379       {
11380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11381       };
11382     }
11383   }
11384 }
11385
11386
11387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
11388   void * jresult ;
11389   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11390   Dali::Vector4 *result = 0 ;
11391
11392   arg1 = (Dali::Matrix *)jarg1;
11393   {
11394     try {
11395       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
11396     } catch (std::out_of_range& e) {
11397       {
11398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11399       };
11400     } catch (std::exception& e) {
11401       {
11402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11403       };
11404     } catch (...) {
11405       {
11406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11407       };
11408     }
11409   }
11410   jresult = (void *)result;
11411   return jresult;
11412 }
11413
11414
11415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
11416   void * jresult ;
11417   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11418   Dali::Vector3 *result = 0 ;
11419
11420   arg1 = (Dali::Matrix *)jarg1;
11421   {
11422     try {
11423       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
11424     } catch (std::out_of_range& e) {
11425       {
11426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11427       };
11428     } catch (std::exception& e) {
11429       {
11430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11431       };
11432     } catch (...) {
11433       {
11434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11435       };
11436     }
11437   }
11438   jresult = (void *)result;
11439   return jresult;
11440 }
11441
11442
11443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
11444   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11445   Dali::Vector4 *arg2 = 0 ;
11446
11447   arg1 = (Dali::Matrix *)jarg1;
11448   arg2 = (Dali::Vector4 *)jarg2;
11449   if (!arg2) {
11450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11451     return ;
11452   }
11453   {
11454     try {
11455       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
11456     } catch (std::out_of_range& e) {
11457       {
11458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11459       };
11460     } catch (std::exception& e) {
11461       {
11462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11463       };
11464     } catch (...) {
11465       {
11466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11467       };
11468     }
11469   }
11470 }
11471
11472
11473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
11474   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11475   Dali::Vector3 *arg2 = 0 ;
11476
11477   arg1 = (Dali::Matrix *)jarg1;
11478   arg2 = (Dali::Vector3 *)jarg2;
11479   if (!arg2) {
11480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11481     return ;
11482   }
11483   {
11484     try {
11485       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
11486     } catch (std::out_of_range& e) {
11487       {
11488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11489       };
11490     } catch (std::exception& e) {
11491       {
11492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11493       };
11494     } catch (...) {
11495       {
11496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11497       };
11498     }
11499   }
11500 }
11501
11502
11503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
11504   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11505
11506   arg1 = (Dali::Matrix *)jarg1;
11507   {
11508     try {
11509       (arg1)->OrthoNormalize();
11510     } catch (std::out_of_range& e) {
11511       {
11512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11513       };
11514     } catch (std::exception& e) {
11515       {
11516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11517       };
11518     } catch (...) {
11519       {
11520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11521       };
11522     }
11523   }
11524 }
11525
11526
11527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
11528   void * jresult ;
11529   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11530   float *result = 0 ;
11531
11532   arg1 = (Dali::Matrix *)jarg1;
11533   {
11534     try {
11535       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
11536     } catch (std::out_of_range& e) {
11537       {
11538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11539       };
11540     } catch (std::exception& e) {
11541       {
11542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11543       };
11544     } catch (...) {
11545       {
11546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11547       };
11548     }
11549   }
11550   jresult = (void *)result;
11551   return jresult;
11552 }
11553
11554
11555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
11556   Dali::Matrix *arg1 = 0 ;
11557   Dali::Matrix *arg2 = 0 ;
11558   Dali::Matrix *arg3 = 0 ;
11559
11560   arg1 = (Dali::Matrix *)jarg1;
11561   if (!arg1) {
11562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11563     return ;
11564   }
11565   arg2 = (Dali::Matrix *)jarg2;
11566   if (!arg2) {
11567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11568     return ;
11569   }
11570   arg3 = (Dali::Matrix *)jarg3;
11571   if (!arg3) {
11572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11573     return ;
11574   }
11575   {
11576     try {
11577       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
11578     } catch (std::out_of_range& e) {
11579       {
11580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11581       };
11582     } catch (std::exception& e) {
11583       {
11584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11585       };
11586     } catch (...) {
11587       {
11588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11589       };
11590     }
11591   }
11592 }
11593
11594
11595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
11596   Dali::Matrix *arg1 = 0 ;
11597   Dali::Matrix *arg2 = 0 ;
11598   Dali::Quaternion *arg3 = 0 ;
11599
11600   arg1 = (Dali::Matrix *)jarg1;
11601   if (!arg1) {
11602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
11603     return ;
11604   }
11605   arg2 = (Dali::Matrix *)jarg2;
11606   if (!arg2) {
11607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11608     return ;
11609   }
11610   arg3 = (Dali::Quaternion *)jarg3;
11611   if (!arg3) {
11612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11613     return ;
11614   }
11615   {
11616     try {
11617       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
11618     } catch (std::out_of_range& e) {
11619       {
11620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11621       };
11622     } catch (std::exception& e) {
11623       {
11624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11625       };
11626     } catch (...) {
11627       {
11628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11629       };
11630     }
11631   }
11632 }
11633
11634
11635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
11636   void * jresult ;
11637   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11638   Dali::Vector4 *arg2 = 0 ;
11639   Dali::Vector4 result;
11640
11641   arg1 = (Dali::Matrix *)jarg1;
11642   arg2 = (Dali::Vector4 *)jarg2;
11643   if (!arg2) {
11644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
11645     return 0;
11646   }
11647   {
11648     try {
11649       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
11650     } catch (std::out_of_range& e) {
11651       {
11652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11653       };
11654     } catch (std::exception& e) {
11655       {
11656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11657       };
11658     } catch (...) {
11659       {
11660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11661       };
11662     }
11663   }
11664   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
11665   return jresult;
11666 }
11667
11668
11669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
11670   unsigned int jresult ;
11671   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11672   Dali::Matrix *arg2 = 0 ;
11673   bool result;
11674
11675   arg1 = (Dali::Matrix *)jarg1;
11676   arg2 = (Dali::Matrix *)jarg2;
11677   if (!arg2) {
11678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11679     return 0;
11680   }
11681   {
11682     try {
11683       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
11684     } catch (std::out_of_range& e) {
11685       {
11686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11687       };
11688     } catch (std::exception& e) {
11689       {
11690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11691       };
11692     } catch (...) {
11693       {
11694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11695       };
11696     }
11697   }
11698   jresult = result;
11699   return jresult;
11700 }
11701
11702
11703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
11704   unsigned int jresult ;
11705   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11706   Dali::Matrix *arg2 = 0 ;
11707   bool result;
11708
11709   arg1 = (Dali::Matrix *)jarg1;
11710   arg2 = (Dali::Matrix *)jarg2;
11711   if (!arg2) {
11712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
11713     return 0;
11714   }
11715   {
11716     try {
11717       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
11718     } catch (std::out_of_range& e) {
11719       {
11720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11721       };
11722     } catch (std::exception& e) {
11723       {
11724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11725       };
11726     } catch (...) {
11727       {
11728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11729       };
11730     }
11731   }
11732   jresult = result;
11733   return jresult;
11734 }
11735
11736
11737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11738   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11739   Dali::Vector3 *arg2 = 0 ;
11740   Dali::Quaternion *arg3 = 0 ;
11741   Dali::Vector3 *arg4 = 0 ;
11742
11743   arg1 = (Dali::Matrix *)jarg1;
11744   arg2 = (Dali::Vector3 *)jarg2;
11745   if (!arg2) {
11746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11747     return ;
11748   }
11749   arg3 = (Dali::Quaternion *)jarg3;
11750   if (!arg3) {
11751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11752     return ;
11753   }
11754   arg4 = (Dali::Vector3 *)jarg4;
11755   if (!arg4) {
11756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11757     return ;
11758   }
11759   {
11760     try {
11761       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11762     } catch (std::out_of_range& e) {
11763       {
11764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11765       };
11766     } catch (std::exception& e) {
11767       {
11768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11769       };
11770     } catch (...) {
11771       {
11772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11773       };
11774     }
11775   }
11776 }
11777
11778
11779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11780   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11781   Dali::Vector3 *arg2 = 0 ;
11782   Dali::Quaternion *arg3 = 0 ;
11783   Dali::Vector3 *arg4 = 0 ;
11784
11785   arg1 = (Dali::Matrix *)jarg1;
11786   arg2 = (Dali::Vector3 *)jarg2;
11787   if (!arg2) {
11788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11789     return ;
11790   }
11791   arg3 = (Dali::Quaternion *)jarg3;
11792   if (!arg3) {
11793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11794     return ;
11795   }
11796   arg4 = (Dali::Vector3 *)jarg4;
11797   if (!arg4) {
11798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11799     return ;
11800   }
11801   {
11802     try {
11803       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
11804     } catch (std::out_of_range& e) {
11805       {
11806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11807       };
11808     } catch (std::exception& e) {
11809       {
11810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11811       };
11812     } catch (...) {
11813       {
11814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11815       };
11816     }
11817   }
11818 }
11819
11820
11821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
11822   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11823   Dali::Vector3 *arg2 = 0 ;
11824   Dali::Vector3 *arg3 = 0 ;
11825   Dali::Vector3 *arg4 = 0 ;
11826   Dali::Vector3 *arg5 = 0 ;
11827
11828   arg1 = (Dali::Matrix *)jarg1;
11829   arg2 = (Dali::Vector3 *)jarg2;
11830   if (!arg2) {
11831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11832     return ;
11833   }
11834   arg3 = (Dali::Vector3 *)jarg3;
11835   if (!arg3) {
11836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11837     return ;
11838   }
11839   arg4 = (Dali::Vector3 *)jarg4;
11840   if (!arg4) {
11841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11842     return ;
11843   }
11844   arg5 = (Dali::Vector3 *)jarg5;
11845   if (!arg5) {
11846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11847     return ;
11848   }
11849   {
11850     try {
11851       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
11852     } catch (std::out_of_range& e) {
11853       {
11854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11855       };
11856     } catch (std::exception& e) {
11857       {
11858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11859       };
11860     } catch (...) {
11861       {
11862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11863       };
11864     }
11865   }
11866 }
11867
11868
11869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
11870   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11871   Dali::Vector3 *arg2 = 0 ;
11872   Dali::Quaternion *arg3 = 0 ;
11873   Dali::Vector3 *arg4 = 0 ;
11874
11875   arg1 = (Dali::Matrix *)jarg1;
11876   arg2 = (Dali::Vector3 *)jarg2;
11877   if (!arg2) {
11878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11879     return ;
11880   }
11881   arg3 = (Dali::Quaternion *)jarg3;
11882   if (!arg3) {
11883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
11884     return ;
11885   }
11886   arg4 = (Dali::Vector3 *)jarg4;
11887   if (!arg4) {
11888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11889     return ;
11890   }
11891   {
11892     try {
11893       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
11894     } catch (std::out_of_range& e) {
11895       {
11896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11897       };
11898     } catch (std::exception& e) {
11899       {
11900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11901       };
11902     } catch (...) {
11903       {
11904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11905       };
11906     }
11907   }
11908 }
11909
11910
11911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
11912   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
11913
11914   arg1 = (Dali::Matrix *)jarg1;
11915   {
11916     try {
11917       delete arg1;
11918     } catch (std::out_of_range& e) {
11919       {
11920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11921       };
11922     } catch (std::exception& e) {
11923       {
11924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11925       };
11926     } catch (...) {
11927       {
11928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11929       };
11930     }
11931   }
11932 }
11933
11934
11935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
11936   void * jresult ;
11937   Dali::Matrix3 *result = 0 ;
11938
11939   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
11940   jresult = (void *)result;
11941   return jresult;
11942 }
11943
11944
11945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
11946   void * jresult ;
11947   Dali::Matrix3 *result = 0 ;
11948
11949   {
11950     try {
11951       result = (Dali::Matrix3 *)new Dali::Matrix3();
11952     } catch (std::out_of_range& e) {
11953       {
11954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11955       };
11956     } catch (std::exception& e) {
11957       {
11958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11959       };
11960     } catch (...) {
11961       {
11962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11963       };
11964     }
11965   }
11966   jresult = (void *)result;
11967   return jresult;
11968 }
11969
11970
11971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
11972   void * jresult ;
11973   Dali::Matrix3 *arg1 = 0 ;
11974   Dali::Matrix3 *result = 0 ;
11975
11976   arg1 = (Dali::Matrix3 *)jarg1;
11977   if (!arg1) {
11978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
11979     return 0;
11980   }
11981   {
11982     try {
11983       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
11984     } catch (std::out_of_range& e) {
11985       {
11986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11987       };
11988     } catch (std::exception& e) {
11989       {
11990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11991       };
11992     } catch (...) {
11993       {
11994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11995       };
11996     }
11997   }
11998   jresult = (void *)result;
11999   return jresult;
12000 }
12001
12002
12003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
12004   void * jresult ;
12005   Dali::Matrix *arg1 = 0 ;
12006   Dali::Matrix3 *result = 0 ;
12007
12008   arg1 = (Dali::Matrix *)jarg1;
12009   if (!arg1) {
12010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12011     return 0;
12012   }
12013   {
12014     try {
12015       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
12016     } catch (std::out_of_range& e) {
12017       {
12018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12019       };
12020     } catch (std::exception& e) {
12021       {
12022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12023       };
12024     } catch (...) {
12025       {
12026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12027       };
12028     }
12029   }
12030   jresult = (void *)result;
12031   return jresult;
12032 }
12033
12034
12035 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) {
12036   void * jresult ;
12037   float arg1 ;
12038   float arg2 ;
12039   float arg3 ;
12040   float arg4 ;
12041   float arg5 ;
12042   float arg6 ;
12043   float arg7 ;
12044   float arg8 ;
12045   float arg9 ;
12046   Dali::Matrix3 *result = 0 ;
12047
12048   arg1 = (float)jarg1;
12049   arg2 = (float)jarg2;
12050   arg3 = (float)jarg3;
12051   arg4 = (float)jarg4;
12052   arg5 = (float)jarg5;
12053   arg6 = (float)jarg6;
12054   arg7 = (float)jarg7;
12055   arg8 = (float)jarg8;
12056   arg9 = (float)jarg9;
12057   {
12058     try {
12059       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
12060     } catch (std::out_of_range& e) {
12061       {
12062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12063       };
12064     } catch (std::exception& e) {
12065       {
12066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12067       };
12068     } catch (...) {
12069       {
12070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12071       };
12072     }
12073   }
12074   jresult = (void *)result;
12075   return jresult;
12076 }
12077
12078
12079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
12080   void * jresult ;
12081   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12082   Dali::Matrix3 *arg2 = 0 ;
12083   Dali::Matrix3 *result = 0 ;
12084
12085   arg1 = (Dali::Matrix3 *)jarg1;
12086   arg2 = (Dali::Matrix3 *)jarg2;
12087   if (!arg2) {
12088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12089     return 0;
12090   }
12091   {
12092     try {
12093       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
12094     } catch (std::out_of_range& e) {
12095       {
12096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12097       };
12098     } catch (std::exception& e) {
12099       {
12100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12101       };
12102     } catch (...) {
12103       {
12104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12105       };
12106     }
12107   }
12108   jresult = (void *)result;
12109   return jresult;
12110 }
12111
12112
12113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
12114   void * jresult ;
12115   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12116   Dali::Matrix *arg2 = 0 ;
12117   Dali::Matrix3 *result = 0 ;
12118
12119   arg1 = (Dali::Matrix3 *)jarg1;
12120   arg2 = (Dali::Matrix *)jarg2;
12121   if (!arg2) {
12122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12123     return 0;
12124   }
12125   {
12126     try {
12127       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12128     } catch (std::out_of_range& e) {
12129       {
12130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12131       };
12132     } catch (std::exception& e) {
12133       {
12134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12135       };
12136     } catch (...) {
12137       {
12138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12139       };
12140     }
12141   }
12142   jresult = (void *)result;
12143   return jresult;
12144 }
12145
12146
12147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
12148   unsigned int jresult ;
12149   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12150   Dali::Matrix3 *arg2 = 0 ;
12151   bool result;
12152
12153   arg1 = (Dali::Matrix3 *)jarg1;
12154   arg2 = (Dali::Matrix3 *)jarg2;
12155   if (!arg2) {
12156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12157     return 0;
12158   }
12159   {
12160     try {
12161       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
12162     } catch (std::out_of_range& e) {
12163       {
12164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12165       };
12166     } catch (std::exception& e) {
12167       {
12168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12169       };
12170     } catch (...) {
12171       {
12172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12173       };
12174     }
12175   }
12176   jresult = result;
12177   return jresult;
12178 }
12179
12180
12181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
12182   unsigned int jresult ;
12183   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12184   Dali::Matrix3 *arg2 = 0 ;
12185   bool result;
12186
12187   arg1 = (Dali::Matrix3 *)jarg1;
12188   arg2 = (Dali::Matrix3 *)jarg2;
12189   if (!arg2) {
12190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12191     return 0;
12192   }
12193   {
12194     try {
12195       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
12196     } catch (std::out_of_range& e) {
12197       {
12198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12199       };
12200     } catch (std::exception& e) {
12201       {
12202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12203       };
12204     } catch (...) {
12205       {
12206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12207       };
12208     }
12209   }
12210   jresult = result;
12211   return jresult;
12212 }
12213
12214
12215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
12216   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12217
12218   arg1 = (Dali::Matrix3 *)jarg1;
12219   {
12220     try {
12221       delete arg1;
12222     } catch (std::out_of_range& e) {
12223       {
12224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12225       };
12226     } catch (std::exception& e) {
12227       {
12228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12229       };
12230     } catch (...) {
12231       {
12232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12233       };
12234     }
12235   }
12236 }
12237
12238
12239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
12240   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12241
12242   arg1 = (Dali::Matrix3 *)jarg1;
12243   {
12244     try {
12245       (arg1)->SetIdentity();
12246     } catch (std::out_of_range& e) {
12247       {
12248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12249       };
12250     } catch (std::exception& e) {
12251       {
12252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12253       };
12254     } catch (...) {
12255       {
12256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12257       };
12258     }
12259   }
12260 }
12261
12262
12263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
12264   void * jresult ;
12265   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12266   float *result = 0 ;
12267
12268   arg1 = (Dali::Matrix3 *)jarg1;
12269   {
12270     try {
12271       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
12272     } catch (std::out_of_range& e) {
12273       {
12274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12275       };
12276     } catch (std::exception& e) {
12277       {
12278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12279       };
12280     } catch (...) {
12281       {
12282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12283       };
12284     }
12285   }
12286   jresult = (void *)result;
12287   return jresult;
12288 }
12289
12290
12291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
12292   unsigned int jresult ;
12293   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12294   bool result;
12295
12296   arg1 = (Dali::Matrix3 *)jarg1;
12297   {
12298     try {
12299       result = (bool)(arg1)->Invert();
12300     } catch (std::out_of_range& e) {
12301       {
12302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12303       };
12304     } catch (std::exception& e) {
12305       {
12306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12307       };
12308     } catch (...) {
12309       {
12310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12311       };
12312     }
12313   }
12314   jresult = result;
12315   return jresult;
12316 }
12317
12318
12319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
12320   unsigned int jresult ;
12321   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12322   bool result;
12323
12324   arg1 = (Dali::Matrix3 *)jarg1;
12325   {
12326     try {
12327       result = (bool)(arg1)->Transpose();
12328     } catch (std::out_of_range& e) {
12329       {
12330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12331       };
12332     } catch (std::exception& e) {
12333       {
12334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12335       };
12336     } catch (...) {
12337       {
12338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12339       };
12340     }
12341   }
12342   jresult = result;
12343   return jresult;
12344 }
12345
12346
12347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
12348   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12349   float arg2 ;
12350
12351   arg1 = (Dali::Matrix3 *)jarg1;
12352   arg2 = (float)jarg2;
12353   {
12354     try {
12355       (arg1)->Scale(arg2);
12356     } catch (std::out_of_range& e) {
12357       {
12358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12359       };
12360     } catch (std::exception& e) {
12361       {
12362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12363       };
12364     } catch (...) {
12365       {
12366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12367       };
12368     }
12369   }
12370 }
12371
12372
12373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
12374   float jresult ;
12375   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12376   float result;
12377
12378   arg1 = (Dali::Matrix3 *)jarg1;
12379   {
12380     try {
12381       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
12382     } catch (std::out_of_range& e) {
12383       {
12384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12385       };
12386     } catch (std::exception& e) {
12387       {
12388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12389       };
12390     } catch (...) {
12391       {
12392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12393       };
12394     }
12395   }
12396   jresult = result;
12397   return jresult;
12398 }
12399
12400
12401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
12402   unsigned int jresult ;
12403   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
12404   bool result;
12405
12406   arg1 = (Dali::Matrix3 *)jarg1;
12407   {
12408     try {
12409       result = (bool)(arg1)->ScaledInverseTranspose();
12410     } catch (std::out_of_range& e) {
12411       {
12412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12413       };
12414     } catch (std::exception& e) {
12415       {
12416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12417       };
12418     } catch (...) {
12419       {
12420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12421       };
12422     }
12423   }
12424   jresult = result;
12425   return jresult;
12426 }
12427
12428
12429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
12430   Dali::Matrix3 *arg1 = 0 ;
12431   Dali::Matrix3 *arg2 = 0 ;
12432   Dali::Matrix3 *arg3 = 0 ;
12433
12434   arg1 = (Dali::Matrix3 *)jarg1;
12435   if (!arg1) {
12436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
12437     return ;
12438   }
12439   arg2 = (Dali::Matrix3 *)jarg2;
12440   if (!arg2) {
12441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12442     return ;
12443   }
12444   arg3 = (Dali::Matrix3 *)jarg3;
12445   if (!arg3) {
12446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
12447     return ;
12448   }
12449   {
12450     try {
12451       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
12452     } catch (std::out_of_range& e) {
12453       {
12454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12455       };
12456     } catch (std::exception& e) {
12457       {
12458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12459       };
12460     } catch (...) {
12461       {
12462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12463       };
12464     }
12465   }
12466 }
12467
12468
12469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
12470   float jresult ;
12471   float arg1 ;
12472   float arg2 ;
12473   float result;
12474
12475   arg1 = (float)jarg1;
12476   arg2 = (float)jarg2;
12477   {
12478     try {
12479       result = (float)Dali::Random::Range(arg1,arg2);
12480     } catch (std::out_of_range& e) {
12481       {
12482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12483       };
12484     } catch (std::exception& e) {
12485       {
12486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12487       };
12488     } catch (...) {
12489       {
12490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12491       };
12492     }
12493   }
12494   jresult = result;
12495   return jresult;
12496 }
12497
12498
12499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
12500   void * jresult ;
12501   Dali::Vector4 result;
12502
12503   {
12504     try {
12505       result = Dali::Random::Axis();
12506     } catch (std::out_of_range& e) {
12507       {
12508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12509       };
12510     } catch (std::exception& e) {
12511       {
12512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12513       };
12514     } catch (...) {
12515       {
12516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12517       };
12518     }
12519   }
12520   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
12521   return jresult;
12522 }
12523
12524
12525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
12526   void * jresult ;
12527   Dali::AngleAxis *result = 0 ;
12528
12529   {
12530     try {
12531       result = (Dali::AngleAxis *)new Dali::AngleAxis();
12532     } catch (std::out_of_range& e) {
12533       {
12534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12535       };
12536     } catch (std::exception& e) {
12537       {
12538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12539       };
12540     } catch (...) {
12541       {
12542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12543       };
12544     }
12545   }
12546   jresult = (void *)result;
12547   return jresult;
12548 }
12549
12550
12551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
12552   void * jresult ;
12553   Dali::Radian arg1 ;
12554   Dali::Vector3 *arg2 = 0 ;
12555   Dali::Radian *argp1 ;
12556   Dali::AngleAxis *result = 0 ;
12557
12558   argp1 = (Dali::Radian *)jarg1;
12559   if (!argp1) {
12560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
12561     return 0;
12562   }
12563   arg1 = *argp1;
12564   arg2 = (Dali::Vector3 *)jarg2;
12565   if (!arg2) {
12566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12567     return 0;
12568   }
12569   {
12570     try {
12571       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
12572     } catch (std::out_of_range& e) {
12573       {
12574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12575       };
12576     } catch (std::exception& e) {
12577       {
12578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12579       };
12580     } catch (...) {
12581       {
12582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12583       };
12584     }
12585   }
12586   jresult = (void *)result;
12587   return jresult;
12588 }
12589
12590
12591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
12592   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12593   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
12594
12595   arg1 = (Dali::AngleAxis *)jarg1;
12596   arg2 = (Dali::Radian *)jarg2;
12597   if (arg1) (arg1)->angle = *arg2;
12598 }
12599
12600
12601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
12602   void * jresult ;
12603   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12604   Dali::Radian *result = 0 ;
12605
12606   arg1 = (Dali::AngleAxis *)jarg1;
12607   result = (Dali::Radian *)& ((arg1)->angle);
12608   jresult = (void *)result;
12609   return jresult;
12610 }
12611
12612
12613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
12614   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12615   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
12616
12617   arg1 = (Dali::AngleAxis *)jarg1;
12618   arg2 = (Dali::Vector3 *)jarg2;
12619   if (arg1) (arg1)->axis = *arg2;
12620 }
12621
12622
12623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
12624   void * jresult ;
12625   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12626   Dali::Vector3 *result = 0 ;
12627
12628   arg1 = (Dali::AngleAxis *)jarg1;
12629   result = (Dali::Vector3 *)& ((arg1)->axis);
12630   jresult = (void *)result;
12631   return jresult;
12632 }
12633
12634
12635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
12636   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
12637
12638   arg1 = (Dali::AngleAxis *)jarg1;
12639   {
12640     try {
12641       delete arg1;
12642     } catch (std::out_of_range& e) {
12643       {
12644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12645       };
12646     } catch (std::exception& e) {
12647       {
12648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12649       };
12650     } catch (...) {
12651       {
12652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12653       };
12654     }
12655   }
12656 }
12657
12658
12659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
12660   unsigned int jresult ;
12661   Dali::AngleAxis *arg1 = 0 ;
12662   Dali::AngleAxis *arg2 = 0 ;
12663   bool result;
12664
12665   arg1 = (Dali::AngleAxis *)jarg1;
12666   if (!arg1) {
12667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12668     return 0;
12669   }
12670   arg2 = (Dali::AngleAxis *)jarg2;
12671   if (!arg2) {
12672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
12673     return 0;
12674   }
12675   {
12676     try {
12677       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
12678     } catch (std::out_of_range& e) {
12679       {
12680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12681       };
12682     } catch (std::exception& e) {
12683       {
12684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12685       };
12686     } catch (...) {
12687       {
12688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12689       };
12690     }
12691   }
12692   jresult = result;
12693   return jresult;
12694 }
12695
12696
12697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
12698   unsigned int jresult ;
12699   unsigned int arg1 ;
12700   unsigned int result;
12701
12702   arg1 = (unsigned int)jarg1;
12703   {
12704     try {
12705       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
12706     } catch (std::out_of_range& e) {
12707       {
12708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12709       };
12710     } catch (std::exception& e) {
12711       {
12712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12713       };
12714     } catch (...) {
12715       {
12716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12717       };
12718     }
12719   }
12720   jresult = result;
12721   return jresult;
12722 }
12723
12724
12725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
12726   unsigned int jresult ;
12727   unsigned int arg1 ;
12728   bool result;
12729
12730   arg1 = (unsigned int)jarg1;
12731   {
12732     try {
12733       result = (bool)Dali::IsPowerOfTwo(arg1);
12734     } catch (std::out_of_range& e) {
12735       {
12736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12737       };
12738     } catch (std::exception& e) {
12739       {
12740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12741       };
12742     } catch (...) {
12743       {
12744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12745       };
12746     }
12747   }
12748   jresult = result;
12749   return jresult;
12750 }
12751
12752
12753 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
12754   float jresult ;
12755   float arg1 ;
12756   float arg2 ;
12757   float result;
12758
12759   arg1 = (float)jarg1;
12760   arg2 = (float)jarg2;
12761   {
12762     try {
12763       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
12764     } catch (std::out_of_range& e) {
12765       {
12766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12767       };
12768     } catch (std::exception& e) {
12769       {
12770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12771       };
12772     } catch (...) {
12773       {
12774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12775       };
12776     }
12777   }
12778   jresult = result;
12779   return jresult;
12780 }
12781
12782
12783 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
12784   unsigned int jresult ;
12785   float arg1 ;
12786   bool result;
12787
12788   arg1 = (float)jarg1;
12789   {
12790     try {
12791       result = (bool)Dali::EqualsZero(arg1);
12792     } catch (std::out_of_range& e) {
12793       {
12794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12795       };
12796     } catch (std::exception& e) {
12797       {
12798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12799       };
12800     } catch (...) {
12801       {
12802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12803       };
12804     }
12805   }
12806   jresult = result;
12807   return jresult;
12808 }
12809
12810
12811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
12812   unsigned int jresult ;
12813   float arg1 ;
12814   float arg2 ;
12815   bool result;
12816
12817   arg1 = (float)jarg1;
12818   arg2 = (float)jarg2;
12819   {
12820     try {
12821       result = (bool)Dali::Equals(arg1,arg2);
12822     } catch (std::out_of_range& e) {
12823       {
12824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12825       };
12826     } catch (std::exception& e) {
12827       {
12828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12829       };
12830     } catch (...) {
12831       {
12832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12833       };
12834     }
12835   }
12836   jresult = result;
12837   return jresult;
12838 }
12839
12840
12841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
12842   unsigned int jresult ;
12843   float arg1 ;
12844   float arg2 ;
12845   float arg3 ;
12846   bool result;
12847
12848   arg1 = (float)jarg1;
12849   arg2 = (float)jarg2;
12850   arg3 = (float)jarg3;
12851   {
12852     try {
12853       result = (bool)Dali::Equals(arg1,arg2,arg3);
12854     } catch (std::out_of_range& e) {
12855       {
12856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12857       };
12858     } catch (std::exception& e) {
12859       {
12860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12861       };
12862     } catch (...) {
12863       {
12864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12865       };
12866     }
12867   }
12868   jresult = result;
12869   return jresult;
12870 }
12871
12872
12873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
12874   float jresult ;
12875   float arg1 ;
12876   int arg2 ;
12877   float result;
12878
12879   arg1 = (float)jarg1;
12880   arg2 = (int)jarg2;
12881   {
12882     try {
12883       result = (float)Dali::Round(arg1,arg2);
12884     } catch (std::out_of_range& e) {
12885       {
12886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12887       };
12888     } catch (std::exception& e) {
12889       {
12890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12891       };
12892     } catch (...) {
12893       {
12894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12895       };
12896     }
12897   }
12898   jresult = result;
12899   return jresult;
12900 }
12901
12902
12903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
12904   float jresult ;
12905   float arg1 ;
12906   float arg2 ;
12907   float arg3 ;
12908   float result;
12909
12910   arg1 = (float)jarg1;
12911   arg2 = (float)jarg2;
12912   arg3 = (float)jarg3;
12913   {
12914     try {
12915       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
12916     } catch (std::out_of_range& e) {
12917       {
12918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12919       };
12920     } catch (std::exception& e) {
12921       {
12922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12923       };
12924     } catch (...) {
12925       {
12926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12927       };
12928     }
12929   }
12930   jresult = result;
12931   return jresult;
12932 }
12933
12934
12935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
12936   float jresult ;
12937   float arg1 ;
12938   float arg2 ;
12939   float arg3 ;
12940   float arg4 ;
12941   float result;
12942
12943   arg1 = (float)jarg1;
12944   arg2 = (float)jarg2;
12945   arg3 = (float)jarg3;
12946   arg4 = (float)jarg4;
12947   {
12948     try {
12949       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
12950     } catch (std::out_of_range& e) {
12951       {
12952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12953       };
12954     } catch (std::exception& e) {
12955       {
12956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12957       };
12958     } catch (...) {
12959       {
12960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12961       };
12962     }
12963   }
12964   jresult = result;
12965   return jresult;
12966 }
12967
12968
12969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
12970   int jresult ;
12971   int result;
12972
12973   result = (int)(int)Dali::Property::INVALID_INDEX;
12974   jresult = result;
12975   return jresult;
12976 }
12977
12978
12979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
12980   int jresult ;
12981   int result;
12982
12983   result = (int)(int)Dali::Property::INVALID_KEY;
12984   jresult = result;
12985   return jresult;
12986 }
12987
12988
12989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
12990   int jresult ;
12991   int result;
12992
12993   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
12994   jresult = result;
12995   return jresult;
12996 }
12997
12998
12999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
13000   void * jresult ;
13001   Dali::Handle *arg1 = 0 ;
13002   Dali::Property::Index arg2 ;
13003   Dali::Property *result = 0 ;
13004
13005   arg1 = (Dali::Handle *)jarg1;
13006   if (!arg1) {
13007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13008     return 0;
13009   }
13010   arg2 = (Dali::Property::Index)jarg2;
13011   {
13012     try {
13013       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
13014     } catch (std::out_of_range& e) {
13015       {
13016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13017       };
13018     } catch (std::exception& e) {
13019       {
13020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13021       };
13022     } catch (...) {
13023       {
13024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13025       };
13026     }
13027   }
13028   jresult = (void *)result;
13029   return jresult;
13030 }
13031
13032
13033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
13034   void * jresult ;
13035   Dali::Handle *arg1 = 0 ;
13036   Dali::Property::Index arg2 ;
13037   int arg3 ;
13038   Dali::Property *result = 0 ;
13039
13040   arg1 = (Dali::Handle *)jarg1;
13041   if (!arg1) {
13042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13043     return 0;
13044   }
13045   arg2 = (Dali::Property::Index)jarg2;
13046   arg3 = (int)jarg3;
13047   {
13048     try {
13049       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
13050     } catch (std::out_of_range& e) {
13051       {
13052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13053       };
13054     } catch (std::exception& e) {
13055       {
13056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13057       };
13058     } catch (...) {
13059       {
13060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13061       };
13062     }
13063   }
13064   jresult = (void *)result;
13065   return jresult;
13066 }
13067
13068
13069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
13070   void * jresult ;
13071   Dali::Handle *arg1 = 0 ;
13072   std::string *arg2 = 0 ;
13073   Dali::Property *result = 0 ;
13074
13075   arg1 = (Dali::Handle *)jarg1;
13076   if (!arg1) {
13077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13078     return 0;
13079   }
13080   if (!jarg2) {
13081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13082     return 0;
13083   }
13084   std::string arg2_str(jarg2);
13085   arg2 = &arg2_str;
13086   {
13087     try {
13088       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
13089     } catch (std::out_of_range& e) {
13090       {
13091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13092       };
13093     } catch (std::exception& e) {
13094       {
13095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13096       };
13097     } catch (...) {
13098       {
13099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13100       };
13101     }
13102   }
13103   jresult = (void *)result;
13104
13105   //argout typemap for const std::string&
13106
13107   return jresult;
13108 }
13109
13110
13111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
13112   void * jresult ;
13113   Dali::Handle *arg1 = 0 ;
13114   std::string *arg2 = 0 ;
13115   int arg3 ;
13116   Dali::Property *result = 0 ;
13117
13118   arg1 = (Dali::Handle *)jarg1;
13119   if (!arg1) {
13120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13121     return 0;
13122   }
13123   if (!jarg2) {
13124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13125     return 0;
13126   }
13127   std::string arg2_str(jarg2);
13128   arg2 = &arg2_str;
13129   arg3 = (int)jarg3;
13130   {
13131     try {
13132       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
13133     } catch (std::out_of_range& e) {
13134       {
13135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13136       };
13137     } catch (std::exception& e) {
13138       {
13139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13140       };
13141     } catch (...) {
13142       {
13143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13144       };
13145     }
13146   }
13147   jresult = (void *)result;
13148
13149   //argout typemap for const std::string&
13150
13151   return jresult;
13152 }
13153
13154
13155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
13156   Dali::Property *arg1 = (Dali::Property *) 0 ;
13157
13158   arg1 = (Dali::Property *)jarg1;
13159   {
13160     try {
13161       delete arg1;
13162     } catch (std::out_of_range& e) {
13163       {
13164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13165       };
13166     } catch (std::exception& e) {
13167       {
13168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13169       };
13170     } catch (...) {
13171       {
13172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13173       };
13174     }
13175   }
13176 }
13177
13178
13179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
13180   Dali::Property *arg1 = (Dali::Property *) 0 ;
13181   Dali::Handle *arg2 = 0 ;
13182
13183   arg1 = (Dali::Property *)jarg1;
13184   arg2 = (Dali::Handle *)jarg2;
13185   if (!arg2) {
13186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
13187     return ;
13188   }
13189   if (arg1) (arg1)->object = *arg2;
13190 }
13191
13192
13193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
13194   void * jresult ;
13195   Dali::Property *arg1 = (Dali::Property *) 0 ;
13196   Dali::Handle *result = 0 ;
13197
13198   arg1 = (Dali::Property *)jarg1;
13199   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
13200   jresult = (void *)result;
13201   return jresult;
13202 }
13203
13204
13205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
13206   Dali::Property *arg1 = (Dali::Property *) 0 ;
13207   Dali::Property::Index arg2 ;
13208
13209   arg1 = (Dali::Property *)jarg1;
13210   arg2 = (Dali::Property::Index)jarg2;
13211   if (arg1) (arg1)->propertyIndex = arg2;
13212 }
13213
13214
13215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
13216   int jresult ;
13217   Dali::Property *arg1 = (Dali::Property *) 0 ;
13218   Dali::Property::Index result;
13219
13220   arg1 = (Dali::Property *)jarg1;
13221   result = (Dali::Property::Index) ((arg1)->propertyIndex);
13222   jresult = result;
13223   return jresult;
13224 }
13225
13226
13227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
13228   Dali::Property *arg1 = (Dali::Property *) 0 ;
13229   int arg2 ;
13230
13231   arg1 = (Dali::Property *)jarg1;
13232   arg2 = (int)jarg2;
13233   if (arg1) (arg1)->componentIndex = arg2;
13234 }
13235
13236
13237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
13238   int jresult ;
13239   Dali::Property *arg1 = (Dali::Property *) 0 ;
13240   int result;
13241
13242   arg1 = (Dali::Property *)jarg1;
13243   result = (int) ((arg1)->componentIndex);
13244   jresult = result;
13245   return jresult;
13246 }
13247
13248
13249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
13250   void * jresult ;
13251   Dali::Property::Array *result = 0 ;
13252
13253   {
13254     try {
13255       result = (Dali::Property::Array *)new Dali::Property::Array();
13256     } catch (std::out_of_range& e) {
13257       {
13258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13259       };
13260     } catch (std::exception& e) {
13261       {
13262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13263       };
13264     } catch (...) {
13265       {
13266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13267       };
13268     }
13269   }
13270   jresult = (void *)result;
13271   return jresult;
13272 }
13273
13274
13275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
13276   void * jresult ;
13277   Dali::Property::Array *arg1 = 0 ;
13278   Dali::Property::Array *result = 0 ;
13279
13280   arg1 = (Dali::Property::Array *)jarg1;
13281   if (!arg1) {
13282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13283     return 0;
13284   }
13285   {
13286     try {
13287       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
13288     } catch (std::out_of_range& e) {
13289       {
13290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13291       };
13292     } catch (std::exception& e) {
13293       {
13294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13295       };
13296     } catch (...) {
13297       {
13298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13299       };
13300     }
13301   }
13302   jresult = (void *)result;
13303   return jresult;
13304 }
13305
13306
13307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
13308   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13309
13310   arg1 = (Dali::Property::Array *)jarg1;
13311   {
13312     try {
13313       delete arg1;
13314     } catch (std::out_of_range& e) {
13315       {
13316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13317       };
13318     } catch (std::exception& e) {
13319       {
13320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13321       };
13322     } catch (...) {
13323       {
13324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13325       };
13326     }
13327   }
13328 }
13329
13330
13331 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
13332   unsigned long jresult ;
13333   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13334   Dali::Property::Array::SizeType result;
13335
13336   arg1 = (Dali::Property::Array *)jarg1;
13337   {
13338     try {
13339       result = ((Dali::Property::Array const *)arg1)->Size();
13340     } catch (std::out_of_range& e) {
13341       {
13342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13343       };
13344     } catch (std::exception& e) {
13345       {
13346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13347       };
13348     } catch (...) {
13349       {
13350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13351       };
13352     }
13353   }
13354   jresult = (unsigned long)result;
13355   return jresult;
13356 }
13357
13358
13359 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
13360   unsigned long jresult ;
13361   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13362   Dali::Property::Array::SizeType result;
13363
13364   arg1 = (Dali::Property::Array *)jarg1;
13365   {
13366     try {
13367       result = ((Dali::Property::Array const *)arg1)->Count();
13368     } catch (std::out_of_range& e) {
13369       {
13370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13371       };
13372     } catch (std::exception& e) {
13373       {
13374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13375       };
13376     } catch (...) {
13377       {
13378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13379       };
13380     }
13381   }
13382   jresult = (unsigned long)result;
13383   return jresult;
13384 }
13385
13386
13387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
13388   unsigned int jresult ;
13389   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13390   bool result;
13391
13392   arg1 = (Dali::Property::Array *)jarg1;
13393   {
13394     try {
13395       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
13396     } catch (std::out_of_range& e) {
13397       {
13398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13399       };
13400     } catch (std::exception& e) {
13401       {
13402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13403       };
13404     } catch (...) {
13405       {
13406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13407       };
13408     }
13409   }
13410   jresult = result;
13411   return jresult;
13412 }
13413
13414
13415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
13416   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13417
13418   arg1 = (Dali::Property::Array *)jarg1;
13419   {
13420     try {
13421       (arg1)->Clear();
13422     } catch (std::out_of_range& e) {
13423       {
13424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13425       };
13426     } catch (std::exception& e) {
13427       {
13428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13429       };
13430     } catch (...) {
13431       {
13432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13433       };
13434     }
13435   }
13436 }
13437
13438
13439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
13440   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13441   Dali::Property::Array::SizeType arg2 ;
13442
13443   arg1 = (Dali::Property::Array *)jarg1;
13444   arg2 = (Dali::Property::Array::SizeType)jarg2;
13445   {
13446     try {
13447       (arg1)->Reserve(arg2);
13448     } catch (std::out_of_range& e) {
13449       {
13450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13451       };
13452     } catch (std::exception& e) {
13453       {
13454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13455       };
13456     } catch (...) {
13457       {
13458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13459       };
13460     }
13461   }
13462 }
13463
13464
13465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
13466   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13467   Dali::Property::Array::SizeType arg2 ;
13468
13469   arg1 = (Dali::Property::Array *)jarg1;
13470   arg2 = (Dali::Property::Array::SizeType)jarg2;
13471   {
13472     try {
13473       (arg1)->Resize(arg2);
13474     } catch (std::out_of_range& e) {
13475       {
13476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13477       };
13478     } catch (std::exception& e) {
13479       {
13480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13481       };
13482     } catch (...) {
13483       {
13484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13485       };
13486     }
13487   }
13488 }
13489
13490
13491 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
13492   unsigned long jresult ;
13493   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13494   Dali::Property::Array::SizeType result;
13495
13496   arg1 = (Dali::Property::Array *)jarg1;
13497   {
13498     try {
13499       result = (arg1)->Capacity();
13500     } catch (std::out_of_range& e) {
13501       {
13502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13503       };
13504     } catch (std::exception& e) {
13505       {
13506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13507       };
13508     } catch (...) {
13509       {
13510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13511       };
13512     }
13513   }
13514   jresult = (unsigned long)result;
13515   return jresult;
13516 }
13517
13518
13519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
13520   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13521   Dali::Property::Value *arg2 = 0 ;
13522
13523   arg1 = (Dali::Property::Array *)jarg1;
13524   arg2 = (Dali::Property::Value *)jarg2;
13525   if (!arg2) {
13526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13527     return ;
13528   }
13529   {
13530     try {
13531       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
13532     } catch (std::out_of_range& e) {
13533       {
13534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13535       };
13536     } catch (std::exception& e) {
13537       {
13538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13539       };
13540     } catch (...) {
13541       {
13542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13543       };
13544     }
13545   }
13546 }
13547
13548
13549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
13550   void * jresult ;
13551   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13552   Dali::Property::Value *arg2 = 0 ;
13553   Dali::Property::Array *result = 0 ;
13554
13555   arg1 = (Dali::Property::Array *)jarg1;
13556   arg2 = (Dali::Property::Value *)jarg2;
13557   if (!arg2) {
13558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
13559     return 0;
13560   }
13561   {
13562     try {
13563       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
13564     } catch (std::out_of_range& e) {
13565       {
13566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13567       };
13568     } catch (std::exception& e) {
13569       {
13570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13571       };
13572     } catch (...) {
13573       {
13574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13575       };
13576     }
13577   }
13578   jresult = (void *)result;
13579   return jresult;
13580 }
13581
13582
13583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
13584   void * jresult ;
13585   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13586   Dali::Property::Array::SizeType arg2 ;
13587   Dali::Property::Value *result = 0 ;
13588
13589   arg1 = (Dali::Property::Array *)jarg1;
13590   arg2 = (Dali::Property::Array::SizeType)jarg2;
13591   {
13592     try {
13593       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
13594     } catch (std::out_of_range& e) {
13595       {
13596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13597       };
13598     } catch (std::exception& e) {
13599       {
13600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13601       };
13602     } catch (...) {
13603       {
13604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13605       };
13606     }
13607   }
13608   jresult = (void *)result;
13609   return jresult;
13610 }
13611
13612
13613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
13614   void * jresult ;
13615   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13616   Dali::Property::Array::SizeType arg2 ;
13617   Dali::Property::Value *result = 0 ;
13618
13619   arg1 = (Dali::Property::Array *)jarg1;
13620   arg2 = (Dali::Property::Array::SizeType)jarg2;
13621   {
13622     try {
13623       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
13624     } catch (std::out_of_range& e) {
13625       {
13626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13627       };
13628     } catch (std::exception& e) {
13629       {
13630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13631       };
13632     } catch (...) {
13633       {
13634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13635       };
13636     }
13637   }
13638   jresult = (void *)result;
13639   return jresult;
13640 }
13641
13642
13643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
13644   void * jresult ;
13645   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
13646   Dali::Property::Array *arg2 = 0 ;
13647   Dali::Property::Array *result = 0 ;
13648
13649   arg1 = (Dali::Property::Array *)jarg1;
13650   arg2 = (Dali::Property::Array *)jarg2;
13651   if (!arg2) {
13652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
13653     return 0;
13654   }
13655   {
13656     try {
13657       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
13658     } catch (std::out_of_range& e) {
13659       {
13660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13661       };
13662     } catch (std::exception& e) {
13663       {
13664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13665       };
13666     } catch (...) {
13667       {
13668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13669       };
13670     }
13671   }
13672   jresult = (void *)result;
13673   return jresult;
13674 }
13675
13676
13677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
13678   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13679   enum Dali::Property::Key::Type arg2 ;
13680
13681   arg1 = (Dali::Property::Key *)jarg1;
13682   arg2 = (enum Dali::Property::Key::Type)jarg2;
13683   if (arg1) (arg1)->type = arg2;
13684 }
13685
13686
13687 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
13688   int jresult ;
13689   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13690   enum Dali::Property::Key::Type result;
13691
13692   arg1 = (Dali::Property::Key *)jarg1;
13693   result = (enum Dali::Property::Key::Type) ((arg1)->type);
13694   jresult = (int)result;
13695   return jresult;
13696 }
13697
13698
13699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
13700   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13701   Dali::Property::Index arg2 ;
13702
13703   arg1 = (Dali::Property::Key *)jarg1;
13704   arg2 = (Dali::Property::Index)jarg2;
13705   if (arg1) (arg1)->indexKey = arg2;
13706 }
13707
13708
13709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
13710   int jresult ;
13711   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13712   Dali::Property::Index result;
13713
13714   arg1 = (Dali::Property::Key *)jarg1;
13715   result = (Dali::Property::Index) ((arg1)->indexKey);
13716   jresult = result;
13717   return jresult;
13718 }
13719
13720
13721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
13722   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13723   std::string *arg2 = 0 ;
13724
13725   arg1 = (Dali::Property::Key *)jarg1;
13726   if (!jarg2) {
13727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13728     return ;
13729   }
13730   std::string arg2_str(jarg2);
13731   arg2 = &arg2_str;
13732   if (arg1) (arg1)->stringKey = *arg2;
13733
13734   //argout typemap for const std::string&
13735
13736 }
13737
13738
13739 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
13740   char * jresult ;
13741   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13742   std::string *result = 0 ;
13743
13744   arg1 = (Dali::Property::Key *)jarg1;
13745   result = (std::string *) & ((arg1)->stringKey);
13746   jresult = SWIG_csharp_string_callback(result->c_str());
13747   return jresult;
13748 }
13749
13750
13751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
13752   void * jresult ;
13753   std::string *arg1 = 0 ;
13754   Dali::Property::Key *result = 0 ;
13755
13756   if (!jarg1) {
13757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13758     return 0;
13759   }
13760   std::string arg1_str(jarg1);
13761   arg1 = &arg1_str;
13762   {
13763     try {
13764       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
13765     } catch (std::out_of_range& e) {
13766       {
13767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13768       };
13769     } catch (std::exception& e) {
13770       {
13771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13772       };
13773     } catch (...) {
13774       {
13775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13776       };
13777     }
13778   }
13779   jresult = (void *)result;
13780
13781   //argout typemap for const std::string&
13782
13783   return jresult;
13784 }
13785
13786
13787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
13788   void * jresult ;
13789   Dali::Property::Index arg1 ;
13790   Dali::Property::Key *result = 0 ;
13791
13792   arg1 = (Dali::Property::Index)jarg1;
13793   {
13794     try {
13795       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
13796     } catch (std::out_of_range& e) {
13797       {
13798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13799       };
13800     } catch (std::exception& e) {
13801       {
13802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13803       };
13804     } catch (...) {
13805       {
13806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13807       };
13808     }
13809   }
13810   jresult = (void *)result;
13811   return jresult;
13812 }
13813
13814
13815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
13816   unsigned int jresult ;
13817   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13818   std::string *arg2 = 0 ;
13819   bool result;
13820
13821   arg1 = (Dali::Property::Key *)jarg1;
13822   if (!jarg2) {
13823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13824     return 0;
13825   }
13826   std::string arg2_str(jarg2);
13827   arg2 = &arg2_str;
13828   {
13829     try {
13830       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
13831     } catch (std::out_of_range& e) {
13832       {
13833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13834       };
13835     } catch (std::exception& e) {
13836       {
13837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13838       };
13839     } catch (...) {
13840       {
13841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13842       };
13843     }
13844   }
13845   jresult = result;
13846
13847   //argout typemap for const std::string&
13848
13849   return jresult;
13850 }
13851
13852
13853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
13854   unsigned int jresult ;
13855   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13856   Dali::Property::Index arg2 ;
13857   bool result;
13858
13859   arg1 = (Dali::Property::Key *)jarg1;
13860   arg2 = (Dali::Property::Index)jarg2;
13861   {
13862     try {
13863       result = (bool)(arg1)->operator ==(arg2);
13864     } catch (std::out_of_range& e) {
13865       {
13866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13867       };
13868     } catch (std::exception& e) {
13869       {
13870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13871       };
13872     } catch (...) {
13873       {
13874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13875       };
13876     }
13877   }
13878   jresult = result;
13879   return jresult;
13880 }
13881
13882
13883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
13884   unsigned int jresult ;
13885   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13886   Dali::Property::Key *arg2 = 0 ;
13887   bool result;
13888
13889   arg1 = (Dali::Property::Key *)jarg1;
13890   arg2 = (Dali::Property::Key *)jarg2;
13891   if (!arg2) {
13892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13893     return 0;
13894   }
13895   {
13896     try {
13897       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
13898     } catch (std::out_of_range& e) {
13899       {
13900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13901       };
13902     } catch (std::exception& e) {
13903       {
13904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13905       };
13906     } catch (...) {
13907       {
13908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13909       };
13910     }
13911   }
13912   jresult = result;
13913   return jresult;
13914 }
13915
13916
13917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
13918   unsigned int jresult ;
13919   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13920   std::string *arg2 = 0 ;
13921   bool result;
13922
13923   arg1 = (Dali::Property::Key *)jarg1;
13924   if (!jarg2) {
13925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
13926     return 0;
13927   }
13928   std::string arg2_str(jarg2);
13929   arg2 = &arg2_str;
13930   {
13931     try {
13932       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
13933     } catch (std::out_of_range& e) {
13934       {
13935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13936       };
13937     } catch (std::exception& e) {
13938       {
13939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13940       };
13941     } catch (...) {
13942       {
13943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13944       };
13945     }
13946   }
13947   jresult = result;
13948
13949   //argout typemap for const std::string&
13950
13951   return jresult;
13952 }
13953
13954
13955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
13956   unsigned int jresult ;
13957   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13958   Dali::Property::Index arg2 ;
13959   bool result;
13960
13961   arg1 = (Dali::Property::Key *)jarg1;
13962   arg2 = (Dali::Property::Index)jarg2;
13963   {
13964     try {
13965       result = (bool)(arg1)->operator !=(arg2);
13966     } catch (std::out_of_range& e) {
13967       {
13968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13969       };
13970     } catch (std::exception& e) {
13971       {
13972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13973       };
13974     } catch (...) {
13975       {
13976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13977       };
13978     }
13979   }
13980   jresult = result;
13981   return jresult;
13982 }
13983
13984
13985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
13986   unsigned int jresult ;
13987   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
13988   Dali::Property::Key *arg2 = 0 ;
13989   bool result;
13990
13991   arg1 = (Dali::Property::Key *)jarg1;
13992   arg2 = (Dali::Property::Key *)jarg2;
13993   if (!arg2) {
13994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
13995     return 0;
13996   }
13997   {
13998     try {
13999       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
14000     } catch (std::out_of_range& e) {
14001       {
14002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14003       };
14004     } catch (std::exception& e) {
14005       {
14006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14007       };
14008     } catch (...) {
14009       {
14010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14011       };
14012     }
14013   }
14014   jresult = result;
14015   return jresult;
14016 }
14017
14018
14019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
14020   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
14021
14022   arg1 = (Dali::Property::Key *)jarg1;
14023   {
14024     try {
14025       delete arg1;
14026     } catch (std::out_of_range& e) {
14027       {
14028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14029       };
14030     } catch (std::exception& e) {
14031       {
14032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14033       };
14034     } catch (...) {
14035       {
14036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14037       };
14038     }
14039   }
14040 }
14041
14042
14043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
14044   void * jresult ;
14045   Dali::Property::Map *result = 0 ;
14046
14047   {
14048     try {
14049       result = (Dali::Property::Map *)new Dali::Property::Map();
14050     } catch (std::out_of_range& e) {
14051       {
14052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14053       };
14054     } catch (std::exception& e) {
14055       {
14056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14057       };
14058     } catch (...) {
14059       {
14060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14061       };
14062     }
14063   }
14064   jresult = (void *)result;
14065   return jresult;
14066 }
14067
14068
14069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
14070   void * jresult ;
14071   Dali::Property::Map *arg1 = 0 ;
14072   Dali::Property::Map *result = 0 ;
14073
14074   arg1 = (Dali::Property::Map *)jarg1;
14075   if (!arg1) {
14076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14077     return 0;
14078   }
14079   {
14080     try {
14081       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
14082     } catch (std::out_of_range& e) {
14083       {
14084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14085       };
14086     } catch (std::exception& e) {
14087       {
14088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14089       };
14090     } catch (...) {
14091       {
14092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14093       };
14094     }
14095   }
14096   jresult = (void *)result;
14097   return jresult;
14098 }
14099
14100
14101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
14102   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14103
14104   arg1 = (Dali::Property::Map *)jarg1;
14105   {
14106     try {
14107       delete arg1;
14108     } catch (std::out_of_range& e) {
14109       {
14110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14111       };
14112     } catch (std::exception& e) {
14113       {
14114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14115       };
14116     } catch (...) {
14117       {
14118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14119       };
14120     }
14121   }
14122 }
14123
14124
14125 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
14126   unsigned long jresult ;
14127   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14128   Dali::Property::Map::SizeType result;
14129
14130   arg1 = (Dali::Property::Map *)jarg1;
14131   {
14132     try {
14133       result = ((Dali::Property::Map const *)arg1)->Count();
14134     } catch (std::out_of_range& e) {
14135       {
14136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14137       };
14138     } catch (std::exception& e) {
14139       {
14140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14141       };
14142     } catch (...) {
14143       {
14144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14145       };
14146     }
14147   }
14148   jresult = (unsigned long)result;
14149   return jresult;
14150 }
14151
14152
14153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
14154   unsigned int jresult ;
14155   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14156   bool result;
14157
14158   arg1 = (Dali::Property::Map *)jarg1;
14159   {
14160     try {
14161       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
14162     } catch (std::out_of_range& e) {
14163       {
14164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14165       };
14166     } catch (std::exception& e) {
14167       {
14168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14169       };
14170     } catch (...) {
14171       {
14172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14173       };
14174     }
14175   }
14176   jresult = result;
14177   return jresult;
14178 }
14179
14180
14181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14182   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14183   char *arg2 = (char *) 0 ;
14184   Dali::Property::Value *arg3 = 0 ;
14185
14186   arg1 = (Dali::Property::Map *)jarg1;
14187   arg2 = (char *)jarg2;
14188   arg3 = (Dali::Property::Value *)jarg3;
14189   if (!arg3) {
14190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14191     return ;
14192   }
14193   {
14194     try {
14195       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
14196     } catch (std::out_of_range& e) {
14197       {
14198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14199       };
14200     } catch (std::exception& e) {
14201       {
14202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14203       };
14204     } catch (...) {
14205       {
14206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14207       };
14208     }
14209   }
14210 }
14211
14212
14213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14214   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14215   Dali::Property::Index arg2 ;
14216   Dali::Property::Value *arg3 = 0 ;
14217
14218   arg1 = (Dali::Property::Map *)jarg1;
14219   arg2 = (Dali::Property::Index)jarg2;
14220   arg3 = (Dali::Property::Value *)jarg3;
14221   if (!arg3) {
14222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14223     return ;
14224   }
14225   {
14226     try {
14227       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
14228     } catch (std::out_of_range& e) {
14229       {
14230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14231       };
14232     } catch (std::exception& e) {
14233       {
14234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14235       };
14236     } catch (...) {
14237       {
14238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14239       };
14240     }
14241   }
14242 }
14243
14244
14245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
14246   void * jresult ;
14247   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14248   char *arg2 = (char *) 0 ;
14249   Dali::Property::Value *arg3 = 0 ;
14250   Dali::Property::Map *result = 0 ;
14251
14252   arg1 = (Dali::Property::Map *)jarg1;
14253   arg2 = (char *)jarg2;
14254   arg3 = (Dali::Property::Value *)jarg3;
14255   if (!arg3) {
14256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14257     return 0;
14258   }
14259   {
14260     try {
14261       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
14262     } catch (std::out_of_range& e) {
14263       {
14264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14265       };
14266     } catch (std::exception& e) {
14267       {
14268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14269       };
14270     } catch (...) {
14271       {
14272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14273       };
14274     }
14275   }
14276   jresult = (void *)result;
14277   return jresult;
14278 }
14279
14280
14281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
14282   void * jresult ;
14283   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14284   Dali::Property::Index arg2 ;
14285   Dali::Property::Value *arg3 = 0 ;
14286   Dali::Property::Map *result = 0 ;
14287
14288   arg1 = (Dali::Property::Map *)jarg1;
14289   arg2 = (Dali::Property::Index)jarg2;
14290   arg3 = (Dali::Property::Value *)jarg3;
14291   if (!arg3) {
14292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
14293     return 0;
14294   }
14295   {
14296     try {
14297       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
14298     } catch (std::out_of_range& e) {
14299       {
14300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14301       };
14302     } catch (std::exception& e) {
14303       {
14304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14305       };
14306     } catch (...) {
14307       {
14308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14309       };
14310     }
14311   }
14312   jresult = (void *)result;
14313   return jresult;
14314 }
14315
14316
14317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
14318   void * jresult ;
14319   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14320   Dali::Property::Map::SizeType arg2 ;
14321   Dali::Property::Value *result = 0 ;
14322
14323   arg1 = (Dali::Property::Map *)jarg1;
14324   arg2 = (Dali::Property::Map::SizeType)jarg2;
14325   {
14326     try {
14327       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
14328     } catch (std::out_of_range& e) {
14329       {
14330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14331       };
14332     } catch (std::exception& e) {
14333       {
14334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14335       };
14336     } catch (...) {
14337       {
14338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14339       };
14340     }
14341   }
14342   jresult = (void *)result;
14343   return jresult;
14344 }
14345
14346
14347 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
14348   char * jresult ;
14349   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14350   Dali::Property::Map::SizeType arg2 ;
14351   std::string *result = 0 ;
14352
14353   arg1 = (Dali::Property::Map *)jarg1;
14354   arg2 = (Dali::Property::Map::SizeType)jarg2;
14355   {
14356     try {
14357       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
14358     } catch (std::out_of_range& e) {
14359       {
14360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14361       };
14362     } catch (std::exception& e) {
14363       {
14364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14365       };
14366     } catch (...) {
14367       {
14368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14369       };
14370     }
14371   }
14372   jresult = SWIG_csharp_string_callback(result->c_str());
14373   return jresult;
14374 }
14375
14376
14377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
14378   void * jresult ;
14379   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14380   Dali::Property::Map::SizeType arg2 ;
14381   SwigValueWrapper< Dali::Property::Key > result;
14382
14383   arg1 = (Dali::Property::Map *)jarg1;
14384   arg2 = (Dali::Property::Map::SizeType)jarg2;
14385   {
14386     try {
14387       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
14388     } catch (std::out_of_range& e) {
14389       {
14390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14391       };
14392     } catch (std::exception& e) {
14393       {
14394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14395       };
14396     } catch (...) {
14397       {
14398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14399       };
14400     }
14401   }
14402   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
14403   return jresult;
14404 }
14405
14406
14407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
14408   void * jresult ;
14409   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14410   Dali::Property::Map::SizeType arg2 ;
14411   StringValuePair *result = 0 ;
14412
14413   arg1 = (Dali::Property::Map *)jarg1;
14414   arg2 = (Dali::Property::Map::SizeType)jarg2;
14415   {
14416     try {
14417       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
14418     } catch (std::out_of_range& e) {
14419       {
14420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14421       };
14422     } catch (std::exception& e) {
14423       {
14424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14425       };
14426     } catch (...) {
14427       {
14428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14429       };
14430     }
14431   }
14432   jresult = (void *)result;
14433   return jresult;
14434 }
14435
14436
14437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
14438   void * jresult ;
14439   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14440   char *arg2 = (char *) 0 ;
14441   Dali::Property::Value *result = 0 ;
14442
14443   arg1 = (Dali::Property::Map *)jarg1;
14444   arg2 = (char *)jarg2;
14445   {
14446     try {
14447       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
14448     } catch (std::out_of_range& e) {
14449       {
14450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14451       };
14452     } catch (std::exception& e) {
14453       {
14454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14455       };
14456     } catch (...) {
14457       {
14458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14459       };
14460     }
14461   }
14462   jresult = (void *)result;
14463   return jresult;
14464 }
14465
14466
14467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
14468   void * jresult ;
14469   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14470   Dali::Property::Index arg2 ;
14471   Dali::Property::Value *result = 0 ;
14472
14473   arg1 = (Dali::Property::Map *)jarg1;
14474   arg2 = (Dali::Property::Index)jarg2;
14475   {
14476     try {
14477       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
14478     } catch (std::out_of_range& e) {
14479       {
14480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14481       };
14482     } catch (std::exception& e) {
14483       {
14484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14485       };
14486     } catch (...) {
14487       {
14488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14489       };
14490     }
14491   }
14492   jresult = (void *)result;
14493   return jresult;
14494 }
14495
14496
14497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
14498   void * jresult ;
14499   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14500   Dali::Property::Index arg2 ;
14501   std::string *arg3 = 0 ;
14502   Dali::Property::Value *result = 0 ;
14503
14504   arg1 = (Dali::Property::Map *)jarg1;
14505   arg2 = (Dali::Property::Index)jarg2;
14506   if (!jarg3) {
14507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14508     return 0;
14509   }
14510   std::string arg3_str(jarg3);
14511   arg3 = &arg3_str;
14512   {
14513     try {
14514       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
14515     } catch (std::out_of_range& e) {
14516       {
14517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14518       };
14519     } catch (std::exception& e) {
14520       {
14521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14522       };
14523     } catch (...) {
14524       {
14525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14526       };
14527     }
14528   }
14529   jresult = (void *)result;
14530
14531   //argout typemap for const std::string&
14532
14533   return jresult;
14534 }
14535
14536
14537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
14538   void * jresult ;
14539   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14540   std::string *arg2 = 0 ;
14541   Dali::Property::Type arg3 ;
14542   Dali::Property::Value *result = 0 ;
14543
14544   arg1 = (Dali::Property::Map *)jarg1;
14545   if (!jarg2) {
14546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14547     return 0;
14548   }
14549   std::string arg2_str(jarg2);
14550   arg2 = &arg2_str;
14551   arg3 = (Dali::Property::Type)jarg3;
14552   {
14553     try {
14554       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
14555     } catch (std::out_of_range& e) {
14556       {
14557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14558       };
14559     } catch (std::exception& e) {
14560       {
14561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14562       };
14563     } catch (...) {
14564       {
14565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14566       };
14567     }
14568   }
14569   jresult = (void *)result;
14570
14571   //argout typemap for const std::string&
14572
14573   return jresult;
14574 }
14575
14576
14577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
14578   void * jresult ;
14579   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14580   Dali::Property::Index arg2 ;
14581   Dali::Property::Type arg3 ;
14582   Dali::Property::Value *result = 0 ;
14583
14584   arg1 = (Dali::Property::Map *)jarg1;
14585   arg2 = (Dali::Property::Index)jarg2;
14586   arg3 = (Dali::Property::Type)jarg3;
14587   {
14588     try {
14589       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
14590     } catch (std::out_of_range& e) {
14591       {
14592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14593       };
14594     } catch (std::exception& e) {
14595       {
14596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14597       };
14598     } catch (...) {
14599       {
14600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14601       };
14602     }
14603   }
14604   jresult = (void *)result;
14605   return jresult;
14606 }
14607
14608
14609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
14610   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14611
14612   arg1 = (Dali::Property::Map *)jarg1;
14613   {
14614     try {
14615       (arg1)->Clear();
14616     } catch (std::out_of_range& e) {
14617       {
14618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14619       };
14620     } catch (std::exception& e) {
14621       {
14622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14623       };
14624     } catch (...) {
14625       {
14626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14627       };
14628     }
14629   }
14630 }
14631
14632
14633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
14634   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14635   Dali::Property::Map *arg2 = 0 ;
14636
14637   arg1 = (Dali::Property::Map *)jarg1;
14638   arg2 = (Dali::Property::Map *)jarg2;
14639   if (!arg2) {
14640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14641     return ;
14642   }
14643   {
14644     try {
14645       (arg1)->Merge((Dali::Property::Map const &)*arg2);
14646     } catch (std::out_of_range& e) {
14647       {
14648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14649       };
14650     } catch (std::exception& e) {
14651       {
14652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14653       };
14654     } catch (...) {
14655       {
14656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14657       };
14658     }
14659   }
14660 }
14661
14662
14663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
14664   void * jresult ;
14665   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14666   std::string *arg2 = 0 ;
14667   Dali::Property::Value *result = 0 ;
14668
14669   arg1 = (Dali::Property::Map *)jarg1;
14670   if (!jarg2) {
14671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14672     return 0;
14673   }
14674   std::string arg2_str(jarg2);
14675   arg2 = &arg2_str;
14676   {
14677     try {
14678       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
14679     } catch (std::out_of_range& e) {
14680       {
14681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14682       };
14683     } catch (std::exception& e) {
14684       {
14685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14686       };
14687     } catch (...) {
14688       {
14689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14690       };
14691     }
14692   }
14693   jresult = (void *)result;
14694
14695   //argout typemap for const std::string&
14696
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
14702   void * jresult ;
14703   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14704   Dali::Property::Index arg2 ;
14705   Dali::Property::Value *result = 0 ;
14706
14707   arg1 = (Dali::Property::Map *)jarg1;
14708   arg2 = (Dali::Property::Index)jarg2;
14709   {
14710     try {
14711       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
14712     } catch (std::out_of_range& e) {
14713       {
14714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14715       };
14716     } catch (std::exception& e) {
14717       {
14718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14719       };
14720     } catch (...) {
14721       {
14722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14723       };
14724     }
14725   }
14726   jresult = (void *)result;
14727   return jresult;
14728 }
14729
14730
14731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
14732   void * jresult ;
14733   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
14734   Dali::Property::Map *arg2 = 0 ;
14735   Dali::Property::Map *result = 0 ;
14736
14737   arg1 = (Dali::Property::Map *)jarg1;
14738   arg2 = (Dali::Property::Map *)jarg2;
14739   if (!arg2) {
14740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
14741     return 0;
14742   }
14743   {
14744     try {
14745       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
14746     } catch (std::out_of_range& e) {
14747       {
14748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14749       };
14750     } catch (std::exception& e) {
14751       {
14752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14753       };
14754     } catch (...) {
14755       {
14756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14757       };
14758     }
14759   }
14760   jresult = (void *)result;
14761   return jresult;
14762 }
14763
14764
14765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
14766   void * jresult ;
14767   Dali::Property::Value *result = 0 ;
14768
14769   {
14770     try {
14771       result = (Dali::Property::Value *)new Dali::Property::Value();
14772     } catch (std::out_of_range& e) {
14773       {
14774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14775       };
14776     } catch (std::exception& e) {
14777       {
14778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14779       };
14780     } catch (...) {
14781       {
14782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14783       };
14784     }
14785   }
14786   jresult = (void *)result;
14787   return jresult;
14788 }
14789
14790
14791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
14792   void * jresult ;
14793   bool arg1 ;
14794   Dali::Property::Value *result = 0 ;
14795
14796   arg1 = jarg1 ? true : false;
14797   {
14798     try {
14799       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14800     } catch (std::out_of_range& e) {
14801       {
14802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14803       };
14804     } catch (std::exception& e) {
14805       {
14806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14807       };
14808     } catch (...) {
14809       {
14810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14811       };
14812     }
14813   }
14814   jresult = (void *)result;
14815   return jresult;
14816 }
14817
14818
14819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
14820   void * jresult ;
14821   int arg1 ;
14822   Dali::Property::Value *result = 0 ;
14823
14824   arg1 = (int)jarg1;
14825   {
14826     try {
14827       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14828     } catch (std::out_of_range& e) {
14829       {
14830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14831       };
14832     } catch (std::exception& e) {
14833       {
14834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14835       };
14836     } catch (...) {
14837       {
14838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14839       };
14840     }
14841   }
14842   jresult = (void *)result;
14843   return jresult;
14844 }
14845
14846
14847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
14848   void * jresult ;
14849   float arg1 ;
14850   Dali::Property::Value *result = 0 ;
14851
14852   arg1 = (float)jarg1;
14853   {
14854     try {
14855       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
14856     } catch (std::out_of_range& e) {
14857       {
14858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14859       };
14860     } catch (std::exception& e) {
14861       {
14862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14863       };
14864     } catch (...) {
14865       {
14866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14867       };
14868     }
14869   }
14870   jresult = (void *)result;
14871   return jresult;
14872 }
14873
14874
14875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
14876   void * jresult ;
14877   Dali::Vector2 *arg1 = 0 ;
14878   Dali::Property::Value *result = 0 ;
14879
14880   arg1 = (Dali::Vector2 *)jarg1;
14881   if (!arg1) {
14882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
14883     return 0;
14884   }
14885   {
14886     try {
14887       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
14888     } catch (std::out_of_range& e) {
14889       {
14890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14891       };
14892     } catch (std::exception& e) {
14893       {
14894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14895       };
14896     } catch (...) {
14897       {
14898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14899       };
14900     }
14901   }
14902   jresult = (void *)result;
14903   return jresult;
14904 }
14905
14906
14907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
14908   void * jresult ;
14909   Dali::Vector3 *arg1 = 0 ;
14910   Dali::Property::Value *result = 0 ;
14911
14912   arg1 = (Dali::Vector3 *)jarg1;
14913   if (!arg1) {
14914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14915     return 0;
14916   }
14917   {
14918     try {
14919       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
14920     } catch (std::out_of_range& e) {
14921       {
14922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14923       };
14924     } catch (std::exception& e) {
14925       {
14926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14927       };
14928     } catch (...) {
14929       {
14930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14931       };
14932     }
14933   }
14934   jresult = (void *)result;
14935   return jresult;
14936 }
14937
14938
14939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
14940   void * jresult ;
14941   Dali::Vector4 *arg1 = 0 ;
14942   Dali::Property::Value *result = 0 ;
14943
14944   arg1 = (Dali::Vector4 *)jarg1;
14945   if (!arg1) {
14946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
14947     return 0;
14948   }
14949   {
14950     try {
14951       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
14952     } catch (std::out_of_range& e) {
14953       {
14954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14955       };
14956     } catch (std::exception& e) {
14957       {
14958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14959       };
14960     } catch (...) {
14961       {
14962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14963       };
14964     }
14965   }
14966   jresult = (void *)result;
14967   return jresult;
14968 }
14969
14970
14971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
14972   void * jresult ;
14973   Dali::Matrix3 *arg1 = 0 ;
14974   Dali::Property::Value *result = 0 ;
14975
14976   arg1 = (Dali::Matrix3 *)jarg1;
14977   if (!arg1) {
14978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
14979     return 0;
14980   }
14981   {
14982     try {
14983       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
14984     } catch (std::out_of_range& e) {
14985       {
14986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14987       };
14988     } catch (std::exception& e) {
14989       {
14990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14991       };
14992     } catch (...) {
14993       {
14994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14995       };
14996     }
14997   }
14998   jresult = (void *)result;
14999   return jresult;
15000 }
15001
15002
15003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
15004   void * jresult ;
15005   Dali::Matrix *arg1 = 0 ;
15006   Dali::Property::Value *result = 0 ;
15007
15008   arg1 = (Dali::Matrix *)jarg1;
15009   if (!arg1) {
15010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
15011     return 0;
15012   }
15013   {
15014     try {
15015       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
15016     } catch (std::out_of_range& e) {
15017       {
15018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15019       };
15020     } catch (std::exception& e) {
15021       {
15022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15023       };
15024     } catch (...) {
15025       {
15026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15027       };
15028     }
15029   }
15030   jresult = (void *)result;
15031   return jresult;
15032 }
15033
15034
15035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
15036   void * jresult ;
15037   Dali::Rect< int > *arg1 = 0 ;
15038   Dali::Property::Value *result = 0 ;
15039
15040   arg1 = (Dali::Rect< int > *)jarg1;
15041   if (!arg1) {
15042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
15043     return 0;
15044   }
15045   {
15046     try {
15047       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
15048     } catch (std::out_of_range& e) {
15049       {
15050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15051       };
15052     } catch (std::exception& e) {
15053       {
15054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15055       };
15056     } catch (...) {
15057       {
15058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15059       };
15060     }
15061   }
15062   jresult = (void *)result;
15063   return jresult;
15064 }
15065
15066
15067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
15068   void * jresult ;
15069   Dali::AngleAxis *arg1 = 0 ;
15070   Dali::Property::Value *result = 0 ;
15071
15072   arg1 = (Dali::AngleAxis *)jarg1;
15073   if (!arg1) {
15074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
15075     return 0;
15076   }
15077   {
15078     try {
15079       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
15080     } catch (std::out_of_range& e) {
15081       {
15082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15083       };
15084     } catch (std::exception& e) {
15085       {
15086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15087       };
15088     } catch (...) {
15089       {
15090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15091       };
15092     }
15093   }
15094   jresult = (void *)result;
15095   return jresult;
15096 }
15097
15098
15099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
15100   void * jresult ;
15101   Dali::Quaternion *arg1 = 0 ;
15102   Dali::Property::Value *result = 0 ;
15103
15104   arg1 = (Dali::Quaternion *)jarg1;
15105   if (!arg1) {
15106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
15107     return 0;
15108   }
15109   {
15110     try {
15111       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
15112     } catch (std::out_of_range& e) {
15113       {
15114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15115       };
15116     } catch (std::exception& e) {
15117       {
15118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15119       };
15120     } catch (...) {
15121       {
15122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15123       };
15124     }
15125   }
15126   jresult = (void *)result;
15127   return jresult;
15128 }
15129
15130
15131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
15132   void * jresult ;
15133   std::string *arg1 = 0 ;
15134   Dali::Property::Value *result = 0 ;
15135
15136   if (!jarg1) {
15137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15138     return 0;
15139   }
15140   std::string arg1_str(jarg1);
15141   arg1 = &arg1_str;
15142   {
15143     try {
15144       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
15145     } catch (std::out_of_range& e) {
15146       {
15147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15148       };
15149     } catch (std::exception& e) {
15150       {
15151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15152       };
15153     } catch (...) {
15154       {
15155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15156       };
15157     }
15158   }
15159   jresult = (void *)result;
15160
15161   //argout typemap for const std::string&
15162
15163   return jresult;
15164 }
15165
15166
15167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
15168   void * jresult ;
15169   Dali::Property::Array *arg1 = 0 ;
15170   Dali::Property::Value *result = 0 ;
15171
15172   arg1 = (Dali::Property::Array *)jarg1;
15173   if (!arg1) {
15174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15175     return 0;
15176   }
15177   {
15178     try {
15179       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15180     } catch (std::out_of_range& e) {
15181       {
15182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15183       };
15184     } catch (std::exception& e) {
15185       {
15186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15187       };
15188     } catch (...) {
15189       {
15190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15191       };
15192     }
15193   }
15194   jresult = (void *)result;
15195   return jresult;
15196 }
15197
15198
15199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
15200   void * jresult ;
15201   Dali::Property::Map *arg1 = 0 ;
15202   Dali::Property::Value *result = 0 ;
15203
15204   arg1 = (Dali::Property::Map *)jarg1;
15205   if (!arg1) {
15206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15207     return 0;
15208   }
15209   {
15210     try {
15211       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
15212     } catch (std::out_of_range& e) {
15213       {
15214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15215       };
15216     } catch (std::exception& e) {
15217       {
15218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15219       };
15220     } catch (...) {
15221       {
15222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15223       };
15224     }
15225   }
15226   jresult = (void *)result;
15227   return jresult;
15228 }
15229
15230
15231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(int jarg1) {
15232   void * jresult ;
15233   Dali::Property::Type arg1 ;
15234   Dali::Property::Value *result = 0 ;
15235
15236   arg1 = (Dali::Property::Type)jarg1;
15237   {
15238     try {
15239       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
15240     } catch (std::out_of_range& e) {
15241       {
15242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15243       };
15244     } catch (std::exception& e) {
15245       {
15246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15247       };
15248     } catch (...) {
15249       {
15250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15251       };
15252     }
15253   }
15254   jresult = (void *)result;
15255   return jresult;
15256 }
15257
15258
15259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(void * jarg1) {
15260   void * jresult ;
15261   Dali::Property::Value *arg1 = 0 ;
15262   Dali::Property::Value *result = 0 ;
15263
15264   arg1 = (Dali::Property::Value *)jarg1;
15265   if (!arg1) {
15266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15267     return 0;
15268   }
15269   {
15270     try {
15271       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
15272     } catch (std::out_of_range& e) {
15273       {
15274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15275       };
15276     } catch (std::exception& e) {
15277       {
15278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15279       };
15280     } catch (...) {
15281       {
15282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15283       };
15284     }
15285   }
15286   jresult = (void *)result;
15287   return jresult;
15288 }
15289
15290
15291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
15292   void * jresult ;
15293   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15294   Dali::Property::Value *arg2 = 0 ;
15295   Dali::Property::Value *result = 0 ;
15296
15297   arg1 = (Dali::Property::Value *)jarg1;
15298   arg2 = (Dali::Property::Value *)jarg2;
15299   if (!arg2) {
15300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15301     return 0;
15302   }
15303   {
15304     try {
15305       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
15306     } catch (std::out_of_range& e) {
15307       {
15308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15309       };
15310     } catch (std::exception& e) {
15311       {
15312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15313       };
15314     } catch (...) {
15315       {
15316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15317       };
15318     }
15319   }
15320   jresult = (void *)result;
15321   return jresult;
15322 }
15323
15324
15325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
15326   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15327
15328   arg1 = (Dali::Property::Value *)jarg1;
15329   {
15330     try {
15331       delete arg1;
15332     } catch (std::out_of_range& e) {
15333       {
15334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15335       };
15336     } catch (std::exception& e) {
15337       {
15338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15339       };
15340     } catch (...) {
15341       {
15342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15343       };
15344     }
15345   }
15346 }
15347
15348
15349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
15350   int jresult ;
15351   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15352   Dali::Property::Type result;
15353
15354   arg1 = (Dali::Property::Value *)jarg1;
15355   {
15356     try {
15357       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
15358     } catch (std::out_of_range& e) {
15359       {
15360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15361       };
15362     } catch (std::exception& e) {
15363       {
15364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15365       };
15366     } catch (...) {
15367       {
15368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15369       };
15370     }
15371   }
15372   jresult = (int)result;
15373   return jresult;
15374 }
15375
15376
15377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
15378   unsigned int jresult ;
15379   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15380   bool *arg2 = 0 ;
15381   bool result;
15382
15383   arg1 = (Dali::Property::Value *)jarg1;
15384   arg2 = (bool *)jarg2;
15385   {
15386     try {
15387       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15388     } catch (std::out_of_range& e) {
15389       {
15390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15391       };
15392     } catch (std::exception& e) {
15393       {
15394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15395       };
15396     } catch (...) {
15397       {
15398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15399       };
15400     }
15401   }
15402   jresult = result;
15403   return jresult;
15404 }
15405
15406
15407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
15408   unsigned int jresult ;
15409   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15410   float *arg2 = 0 ;
15411   bool result;
15412
15413   arg1 = (Dali::Property::Value *)jarg1;
15414   arg2 = (float *)jarg2;
15415   {
15416     try {
15417       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15418     } catch (std::out_of_range& e) {
15419       {
15420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15421       };
15422     } catch (std::exception& e) {
15423       {
15424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15425       };
15426     } catch (...) {
15427       {
15428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15429       };
15430     }
15431   }
15432   jresult = result;
15433   return jresult;
15434 }
15435
15436
15437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
15438   unsigned int jresult ;
15439   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15440   int *arg2 = 0 ;
15441   bool result;
15442
15443   arg1 = (Dali::Property::Value *)jarg1;
15444   arg2 = (int *)jarg2;
15445   {
15446     try {
15447       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15448     } catch (std::out_of_range& e) {
15449       {
15450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15451       };
15452     } catch (std::exception& e) {
15453       {
15454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15455       };
15456     } catch (...) {
15457       {
15458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15459       };
15460     }
15461   }
15462   jresult = result;
15463   return jresult;
15464 }
15465
15466
15467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
15468   unsigned int jresult ;
15469   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15470   Dali::Rect< int > *arg2 = 0 ;
15471   bool result;
15472
15473   arg1 = (Dali::Property::Value *)jarg1;
15474   arg2 = (Dali::Rect< int > *)jarg2;
15475   if (!arg2) {
15476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
15477     return 0;
15478   }
15479   {
15480     try {
15481       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15482     } catch (std::out_of_range& e) {
15483       {
15484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15485       };
15486     } catch (std::exception& e) {
15487       {
15488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15489       };
15490     } catch (...) {
15491       {
15492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15493       };
15494     }
15495   }
15496   jresult = result;
15497   return jresult;
15498 }
15499
15500
15501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
15502   unsigned int jresult ;
15503   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15504   Dali::Vector2 *arg2 = 0 ;
15505   bool result;
15506
15507   arg1 = (Dali::Property::Value *)jarg1;
15508   arg2 = (Dali::Vector2 *)jarg2;
15509   if (!arg2) {
15510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
15511     return 0;
15512   }
15513   {
15514     try {
15515       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15516     } catch (std::out_of_range& e) {
15517       {
15518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15519       };
15520     } catch (std::exception& e) {
15521       {
15522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15523       };
15524     } catch (...) {
15525       {
15526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15527       };
15528     }
15529   }
15530   jresult = result;
15531   return jresult;
15532 }
15533
15534
15535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
15536   unsigned int jresult ;
15537   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15538   Dali::Vector3 *arg2 = 0 ;
15539   bool result;
15540
15541   arg1 = (Dali::Property::Value *)jarg1;
15542   arg2 = (Dali::Vector3 *)jarg2;
15543   if (!arg2) {
15544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
15545     return 0;
15546   }
15547   {
15548     try {
15549       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15550     } catch (std::out_of_range& e) {
15551       {
15552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15553       };
15554     } catch (std::exception& e) {
15555       {
15556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15557       };
15558     } catch (...) {
15559       {
15560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15561       };
15562     }
15563   }
15564   jresult = result;
15565   return jresult;
15566 }
15567
15568
15569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
15570   unsigned int jresult ;
15571   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15572   Dali::Vector4 *arg2 = 0 ;
15573   bool result;
15574
15575   arg1 = (Dali::Property::Value *)jarg1;
15576   arg2 = (Dali::Vector4 *)jarg2;
15577   if (!arg2) {
15578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
15579     return 0;
15580   }
15581   {
15582     try {
15583       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15584     } catch (std::out_of_range& e) {
15585       {
15586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15587       };
15588     } catch (std::exception& e) {
15589       {
15590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15591       };
15592     } catch (...) {
15593       {
15594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15595       };
15596     }
15597   }
15598   jresult = result;
15599   return jresult;
15600 }
15601
15602
15603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
15604   unsigned int jresult ;
15605   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15606   Dali::Matrix3 *arg2 = 0 ;
15607   bool result;
15608
15609   arg1 = (Dali::Property::Value *)jarg1;
15610   arg2 = (Dali::Matrix3 *)jarg2;
15611   if (!arg2) {
15612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
15613     return 0;
15614   }
15615   {
15616     try {
15617       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15618     } catch (std::out_of_range& e) {
15619       {
15620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15621       };
15622     } catch (std::exception& e) {
15623       {
15624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15625       };
15626     } catch (...) {
15627       {
15628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15629       };
15630     }
15631   }
15632   jresult = result;
15633   return jresult;
15634 }
15635
15636
15637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
15638   unsigned int jresult ;
15639   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15640   Dali::Matrix *arg2 = 0 ;
15641   bool result;
15642
15643   arg1 = (Dali::Property::Value *)jarg1;
15644   arg2 = (Dali::Matrix *)jarg2;
15645   if (!arg2) {
15646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
15647     return 0;
15648   }
15649   {
15650     try {
15651       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15652     } catch (std::out_of_range& e) {
15653       {
15654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15655       };
15656     } catch (std::exception& e) {
15657       {
15658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15659       };
15660     } catch (...) {
15661       {
15662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15663       };
15664     }
15665   }
15666   jresult = result;
15667   return jresult;
15668 }
15669
15670
15671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
15672   unsigned int jresult ;
15673   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15674   Dali::AngleAxis *arg2 = 0 ;
15675   bool result;
15676
15677   arg1 = (Dali::Property::Value *)jarg1;
15678   arg2 = (Dali::AngleAxis *)jarg2;
15679   if (!arg2) {
15680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
15681     return 0;
15682   }
15683   {
15684     try {
15685       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15686     } catch (std::out_of_range& e) {
15687       {
15688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15689       };
15690     } catch (std::exception& e) {
15691       {
15692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15693       };
15694     } catch (...) {
15695       {
15696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15697       };
15698     }
15699   }
15700   jresult = result;
15701   return jresult;
15702 }
15703
15704
15705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
15706   unsigned int jresult ;
15707   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15708   Dali::Quaternion *arg2 = 0 ;
15709   bool result;
15710
15711   arg1 = (Dali::Property::Value *)jarg1;
15712   arg2 = (Dali::Quaternion *)jarg2;
15713   if (!arg2) {
15714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
15715     return 0;
15716   }
15717   {
15718     try {
15719       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15720     } catch (std::out_of_range& e) {
15721       {
15722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15723       };
15724     } catch (std::exception& e) {
15725       {
15726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15727       };
15728     } catch (...) {
15729       {
15730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15731       };
15732     }
15733   }
15734   jresult = result;
15735   return jresult;
15736 }
15737
15738
15739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
15740   unsigned int jresult ;
15741   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15742   std::string *arg2 = 0 ;
15743   bool result;
15744
15745   arg1 = (Dali::Property::Value *)jarg1;
15746
15747   //typemap in
15748   std::string temp;
15749   arg2 = &temp;
15750
15751   {
15752     try {
15753       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15754     } catch (std::out_of_range& e) {
15755       {
15756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15757       };
15758     } catch (std::exception& e) {
15759       {
15760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15761       };
15762     } catch (...) {
15763       {
15764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15765       };
15766     }
15767   }
15768   jresult = result;
15769
15770   //Typemap argout in c++ file.
15771   //This will convert c++ string to c# string
15772   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
15773
15774   return jresult;
15775 }
15776
15777
15778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
15779   unsigned int jresult ;
15780   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15781   Dali::Property::Array *arg2 = 0 ;
15782   bool result;
15783
15784   arg1 = (Dali::Property::Value *)jarg1;
15785   arg2 = (Dali::Property::Array *)jarg2;
15786   if (!arg2) {
15787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
15788     return 0;
15789   }
15790   {
15791     try {
15792       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15793     } catch (std::out_of_range& e) {
15794       {
15795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15796       };
15797     } catch (std::exception& e) {
15798       {
15799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15800       };
15801     } catch (...) {
15802       {
15803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15804       };
15805     }
15806   }
15807   jresult = result;
15808   return jresult;
15809 }
15810
15811
15812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
15813   unsigned int jresult ;
15814   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15815   Dali::Property::Map *arg2 = 0 ;
15816   bool result;
15817
15818   arg1 = (Dali::Property::Value *)jarg1;
15819   arg2 = (Dali::Property::Map *)jarg2;
15820   if (!arg2) {
15821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
15822     return 0;
15823   }
15824   {
15825     try {
15826       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
15827     } catch (std::out_of_range& e) {
15828       {
15829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15830       };
15831     } catch (std::exception& e) {
15832       {
15833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15834       };
15835     } catch (...) {
15836       {
15837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15838       };
15839     }
15840   }
15841   jresult = result;
15842   return jresult;
15843 }
15844
15845
15846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
15847   void * jresult ;
15848   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15849   Dali::Property::Array *result = 0 ;
15850
15851   arg1 = (Dali::Property::Value *)jarg1;
15852   {
15853     try {
15854       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
15855     } catch (std::out_of_range& e) {
15856       {
15857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15858       };
15859     } catch (std::exception& e) {
15860       {
15861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15862       };
15863     } catch (...) {
15864       {
15865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15866       };
15867     }
15868   }
15869   jresult = (void *)result;
15870   return jresult;
15871 }
15872
15873
15874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
15875   void * jresult ;
15876   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
15877   Dali::Property::Map *result = 0 ;
15878
15879   arg1 = (Dali::Property::Value *)jarg1;
15880   {
15881     try {
15882       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
15883     } catch (std::out_of_range& e) {
15884       {
15885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15886       };
15887     } catch (std::exception& e) {
15888       {
15889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15890       };
15891     } catch (...) {
15892       {
15893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15894       };
15895     }
15896   }
15897   jresult = (void *)result;
15898   return jresult;
15899 }
15900
15901
15902 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
15903   char * jresult ;
15904   Dali::Property::Type arg1 ;
15905   char *result = 0 ;
15906
15907   arg1 = (Dali::Property::Type)jarg1;
15908   {
15909     try {
15910       result = (char *)Dali::PropertyTypes::GetName(arg1);
15911     } catch (std::out_of_range& e) {
15912       {
15913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15914       };
15915     } catch (std::exception& e) {
15916       {
15917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15918       };
15919     } catch (...) {
15920       {
15921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15922       };
15923     }
15924   }
15925   jresult = SWIG_csharp_string_callback((const char *)result);
15926   return jresult;
15927 }
15928
15929
15930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
15931   unsigned int jresult ;
15932   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15933   std::string *arg2 = 0 ;
15934   Dali::Property::Map *arg3 = 0 ;
15935   bool result;
15936
15937   arg1 = (Dali::BaseObject *)jarg1;
15938   if (!jarg2) {
15939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15940     return 0;
15941   }
15942   std::string arg2_str(jarg2);
15943   arg2 = &arg2_str;
15944   arg3 = (Dali::Property::Map *)jarg3;
15945   if (!arg3) {
15946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15947     return 0;
15948   }
15949   {
15950     try {
15951       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
15952     } catch (std::out_of_range& e) {
15953       {
15954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15955       };
15956     } catch (std::exception& e) {
15957       {
15958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15959       };
15960     } catch (...) {
15961       {
15962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15963       };
15964     }
15965   }
15966   jresult = result;
15967
15968   //argout typemap for const std::string&
15969
15970   return jresult;
15971 }
15972
15973
15974 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
15975   char * jresult ;
15976   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
15977   std::string *result = 0 ;
15978
15979   arg1 = (Dali::BaseObject *)jarg1;
15980   {
15981     try {
15982       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
15983     } catch (std::out_of_range& e) {
15984       {
15985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15986       };
15987     } catch (std::exception& e) {
15988       {
15989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15990       };
15991     } catch (...) {
15992       {
15993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15994       };
15995     }
15996   }
15997   jresult = SWIG_csharp_string_callback(result->c_str());
15998   return jresult;
15999 }
16000
16001
16002 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
16003   unsigned int jresult ;
16004   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16005   Dali::TypeInfo *arg2 = 0 ;
16006   bool result;
16007
16008   arg1 = (Dali::BaseObject *)jarg1;
16009   arg2 = (Dali::TypeInfo *)jarg2;
16010   if (!arg2) {
16011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16012     return 0;
16013   }
16014   {
16015     try {
16016       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
16017     } catch (std::out_of_range& e) {
16018       {
16019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16020       };
16021     } catch (std::exception& e) {
16022       {
16023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16024       };
16025     } catch (...) {
16026       {
16027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16028       };
16029     }
16030   }
16031   jresult = result;
16032   return jresult;
16033 }
16034
16035
16036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
16037   unsigned int jresult ;
16038   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16039   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
16040   std::string *arg3 = 0 ;
16041   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
16042   bool result;
16043
16044   arg1 = (Dali::BaseObject *)jarg1;
16045   arg2 = (ConnectionTrackerInterface *)jarg2;
16046   if (!jarg3) {
16047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16048     return 0;
16049   }
16050   std::string arg3_str(jarg3);
16051   arg3 = &arg3_str;
16052   arg4 = (FunctorDelegate *)jarg4;
16053   {
16054     try {
16055       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
16056     } catch (std::out_of_range& e) {
16057       {
16058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16059       };
16060     } catch (std::exception& e) {
16061       {
16062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16063       };
16064     } catch (...) {
16065       {
16066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16067       };
16068     }
16069   }
16070   jresult = result;
16071
16072   //argout typemap for const std::string&
16073
16074   return jresult;
16075 }
16076
16077
16078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
16079   void * jresult ;
16080   Dali::BaseHandle *arg1 = 0 ;
16081   Dali::BaseObject *result = 0 ;
16082
16083   arg1 = (Dali::BaseHandle *)jarg1;
16084   if (!arg1) {
16085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16086     return 0;
16087   }
16088   {
16089     try {
16090       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
16091     } catch (std::out_of_range& e) {
16092       {
16093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16094       };
16095     } catch (std::exception& e) {
16096       {
16097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16098       };
16099     } catch (...) {
16100       {
16101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16102       };
16103     }
16104   }
16105   jresult = (void *)result;
16106   return jresult;
16107 }
16108
16109
16110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
16111   void * jresult ;
16112   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
16113   Dali::BaseHandle *result = 0 ;
16114
16115   arg1 = (Dali::BaseObject *)jarg1;
16116   {
16117     try {
16118       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
16119     } catch (std::out_of_range& e) {
16120       {
16121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16122       };
16123     } catch (std::exception& e) {
16124       {
16125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16126       };
16127     } catch (...) {
16128       {
16129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16130       };
16131     }
16132   }
16133   jresult = (void *)result;
16134   return jresult;
16135 }
16136
16137
16138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
16139   void * jresult ;
16140   Dali::BaseHandle *result = 0 ;
16141
16142   {
16143     try {
16144       result = (Dali::BaseHandle *)new Dali::BaseHandle();
16145     } catch (std::out_of_range& e) {
16146       {
16147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16148       };
16149     } catch (std::exception& e) {
16150       {
16151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16152       };
16153     } catch (...) {
16154       {
16155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16156       };
16157     }
16158   }
16159   jresult = (void *)result;
16160   return jresult;
16161 }
16162
16163
16164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
16165   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16166
16167   arg1 = (Dali::BaseHandle *)jarg1;
16168   {
16169     try {
16170       delete arg1;
16171     } catch (std::out_of_range& e) {
16172       {
16173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16174       };
16175     } catch (std::exception& e) {
16176       {
16177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16178       };
16179     } catch (...) {
16180       {
16181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16182       };
16183     }
16184   }
16185 }
16186
16187
16188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
16189   void * jresult ;
16190   Dali::BaseHandle *arg1 = 0 ;
16191   Dali::BaseHandle *result = 0 ;
16192
16193   arg1 = (Dali::BaseHandle *)jarg1;
16194   if (!arg1) {
16195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16196     return 0;
16197   }
16198   {
16199     try {
16200       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
16201     } catch (std::out_of_range& e) {
16202       {
16203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16204       };
16205     } catch (std::exception& e) {
16206       {
16207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16208       };
16209     } catch (...) {
16210       {
16211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16212       };
16213     }
16214   }
16215   jresult = (void *)result;
16216   return jresult;
16217 }
16218
16219
16220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
16221   void * jresult ;
16222   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16223   Dali::BaseHandle *arg2 = 0 ;
16224   Dali::BaseHandle *result = 0 ;
16225
16226   arg1 = (Dali::BaseHandle *)jarg1;
16227   arg2 = (Dali::BaseHandle *)jarg2;
16228   if (!arg2) {
16229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16230     return 0;
16231   }
16232   {
16233     try {
16234       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
16235     } catch (std::out_of_range& e) {
16236       {
16237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16238       };
16239     } catch (std::exception& e) {
16240       {
16241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16242       };
16243     } catch (...) {
16244       {
16245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16246       };
16247     }
16248   }
16249   jresult = (void *)result;
16250   return jresult;
16251 }
16252
16253
16254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
16255   unsigned int jresult ;
16256   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16257   std::string *arg2 = 0 ;
16258   Dali::Property::Map *arg3 = 0 ;
16259   bool result;
16260
16261   arg1 = (Dali::BaseHandle *)jarg1;
16262   if (!jarg2) {
16263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16264     return 0;
16265   }
16266   std::string arg2_str(jarg2);
16267   arg2 = &arg2_str;
16268   arg3 = (Dali::Property::Map *)jarg3;
16269   if (!arg3) {
16270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16271     return 0;
16272   }
16273   {
16274     try {
16275       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
16276     } catch (std::out_of_range& e) {
16277       {
16278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16279       };
16280     } catch (std::exception& e) {
16281       {
16282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16283       };
16284     } catch (...) {
16285       {
16286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16287       };
16288     }
16289   }
16290   jresult = result;
16291
16292   //argout typemap for const std::string&
16293
16294   return jresult;
16295 }
16296
16297
16298 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
16299   char * jresult ;
16300   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16301   std::string *result = 0 ;
16302
16303   arg1 = (Dali::BaseHandle *)jarg1;
16304   {
16305     try {
16306       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
16307     } catch (std::out_of_range& e) {
16308       {
16309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16310       };
16311     } catch (std::exception& e) {
16312       {
16313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16314       };
16315     } catch (...) {
16316       {
16317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16318       };
16319     }
16320   }
16321   jresult = SWIG_csharp_string_callback(result->c_str());
16322   return jresult;
16323 }
16324
16325
16326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
16327   unsigned int jresult ;
16328   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16329   Dali::TypeInfo *arg2 = 0 ;
16330   bool result;
16331
16332   arg1 = (Dali::BaseHandle *)jarg1;
16333   arg2 = (Dali::TypeInfo *)jarg2;
16334   if (!arg2) {
16335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
16336     return 0;
16337   }
16338   {
16339     try {
16340       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
16341     } catch (std::out_of_range& e) {
16342       {
16343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16344       };
16345     } catch (std::exception& e) {
16346       {
16347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16348       };
16349     } catch (...) {
16350       {
16351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16352       };
16353     }
16354   }
16355   jresult = result;
16356   return jresult;
16357 }
16358
16359
16360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
16361   void * jresult ;
16362   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16363   Dali::BaseObject *result = 0 ;
16364
16365   arg1 = (Dali::BaseHandle *)jarg1;
16366   {
16367     try {
16368       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
16369     } catch (std::out_of_range& e) {
16370       {
16371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16372       };
16373     } catch (std::exception& e) {
16374       {
16375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16376       };
16377     } catch (...) {
16378       {
16379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16380       };
16381     }
16382   }
16383   jresult = (void *)result;
16384   return jresult;
16385 }
16386
16387
16388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
16389   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16390
16391   arg1 = (Dali::BaseHandle *)jarg1;
16392   {
16393     try {
16394       (arg1)->Reset();
16395     } catch (std::out_of_range& e) {
16396       {
16397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16398       };
16399     } catch (std::exception& e) {
16400       {
16401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16402       };
16403     } catch (...) {
16404       {
16405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16406       };
16407     }
16408   }
16409 }
16410
16411
16412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
16413   unsigned int jresult ;
16414   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16415   Dali::BaseHandle *arg2 = 0 ;
16416   bool result;
16417
16418   arg1 = (Dali::BaseHandle *)jarg1;
16419   arg2 = (Dali::BaseHandle *)jarg2;
16420   if (!arg2) {
16421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16422     return 0;
16423   }
16424   {
16425     try {
16426       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
16427     } catch (std::out_of_range& e) {
16428       {
16429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16430       };
16431     } catch (std::exception& e) {
16432       {
16433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16434       };
16435     } catch (...) {
16436       {
16437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16438       };
16439     }
16440   }
16441   jresult = result;
16442   return jresult;
16443 }
16444
16445
16446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
16447   unsigned int jresult ;
16448   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16449   Dali::BaseHandle *arg2 = 0 ;
16450   bool result;
16451
16452   arg1 = (Dali::BaseHandle *)jarg1;
16453   arg2 = (Dali::BaseHandle *)jarg2;
16454   if (!arg2) {
16455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16456     return 0;
16457   }
16458   {
16459     try {
16460       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
16461     } catch (std::out_of_range& e) {
16462       {
16463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16464       };
16465     } catch (std::exception& e) {
16466       {
16467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16468       };
16469     } catch (...) {
16470       {
16471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16472       };
16473     }
16474   }
16475   jresult = result;
16476   return jresult;
16477 }
16478
16479
16480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
16481   void * jresult ;
16482   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16483   Dali::RefObject *result = 0 ;
16484
16485   arg1 = (Dali::BaseHandle *)jarg1;
16486   {
16487     try {
16488       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
16489     } catch (std::out_of_range& e) {
16490       {
16491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16492       };
16493     } catch (std::exception& e) {
16494       {
16495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16496       };
16497     } catch (...) {
16498       {
16499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16500       };
16501     }
16502   }
16503   jresult = (void *)result;
16504   return jresult;
16505 }
16506
16507
16508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
16509   unsigned int jresult ;
16510   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16511   bool result;
16512
16513   arg1 = (Dali::BaseHandle *)jarg1;
16514   {
16515     try {
16516       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
16517     } catch (std::out_of_range& e) {
16518       {
16519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16520       };
16521     } catch (std::exception& e) {
16522       {
16523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16524       };
16525     } catch (...) {
16526       {
16527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16528       };
16529     }
16530   }
16531   jresult = result;
16532   return jresult;
16533 }
16534
16535
16536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
16537   unsigned int jresult ;
16538   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
16539   Dali::BaseHandle *arg2 = 0 ;
16540   bool result;
16541
16542   arg1 = (Dali::BaseHandle *)jarg1;
16543   arg2 = (Dali::BaseHandle *)jarg2;
16544   if (!arg2) {
16545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16546     return 0;
16547   }
16548   {
16549     try {
16550       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
16551     } catch (std::out_of_range& e) {
16552       {
16553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16554       };
16555     } catch (std::exception& e) {
16556       {
16557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16558       };
16559     } catch (...) {
16560       {
16561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16562       };
16563     }
16564   }
16565   jresult = result;
16566   return jresult;
16567 }
16568
16569
16570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
16571   unsigned int jresult ;
16572   Dali::BaseHandle *arg1 = 0 ;
16573   Dali::BaseHandle *arg2 = 0 ;
16574   bool result;
16575
16576   arg1 = (Dali::BaseHandle *)jarg1;
16577   if (!arg1) {
16578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16579     return 0;
16580   }
16581   arg2 = (Dali::BaseHandle *)jarg2;
16582   if (!arg2) {
16583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
16584     return 0;
16585   }
16586   {
16587     try {
16588       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
16589     } catch (std::out_of_range& e) {
16590       {
16591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16592       };
16593     } catch (std::exception& e) {
16594       {
16595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16596       };
16597     } catch (...) {
16598       {
16599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16600       };
16601     }
16602   }
16603   jresult = result;
16604   return jresult;
16605 }
16606
16607
16608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
16609   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16610
16611   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16612   {
16613     try {
16614       delete arg1;
16615     } catch (std::out_of_range& e) {
16616       {
16617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16618       };
16619     } catch (std::exception& e) {
16620       {
16621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16622       };
16623     } catch (...) {
16624       {
16625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16626       };
16627     }
16628   }
16629 }
16630
16631
16632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16633   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
16634   SlotObserver *arg2 = (SlotObserver *) 0 ;
16635   CallbackBase *arg3 = (CallbackBase *) 0 ;
16636
16637   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
16638   arg2 = (SlotObserver *)jarg2;
16639   arg3 = (CallbackBase *)jarg3;
16640   {
16641     try {
16642       (arg1)->SignalConnected(arg2,arg3);
16643     } catch (std::out_of_range& e) {
16644       {
16645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16646       };
16647     } catch (std::exception& e) {
16648       {
16649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16650       };
16651     } catch (...) {
16652       {
16653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16654       };
16655     }
16656   }
16657 }
16658
16659
16660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
16661   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16662
16663   arg1 = (Dali::SignalObserver *)jarg1;
16664   {
16665     try {
16666       delete arg1;
16667     } catch (std::out_of_range& e) {
16668       {
16669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16670       };
16671     } catch (std::exception& e) {
16672       {
16673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16674       };
16675     } catch (...) {
16676       {
16677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16678       };
16679     }
16680   }
16681 }
16682
16683
16684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16685   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
16686   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16687   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16688
16689   arg1 = (Dali::SignalObserver *)jarg1;
16690   arg2 = (Dali::SlotObserver *)jarg2;
16691   arg3 = (Dali::CallbackBase *)jarg3;
16692   {
16693     try {
16694       (arg1)->SignalDisconnected(arg2,arg3);
16695     } catch (std::out_of_range& e) {
16696       {
16697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16698       };
16699     } catch (std::exception& e) {
16700       {
16701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16702       };
16703     } catch (...) {
16704       {
16705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16706       };
16707     }
16708   }
16709 }
16710
16711
16712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
16713   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16714
16715   arg1 = (Dali::SlotObserver *)jarg1;
16716   {
16717     try {
16718       delete arg1;
16719     } catch (std::out_of_range& e) {
16720       {
16721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16722       };
16723     } catch (std::exception& e) {
16724       {
16725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16726       };
16727     } catch (...) {
16728       {
16729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16730       };
16731     }
16732   }
16733 }
16734
16735
16736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
16737   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
16738   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
16739
16740   arg1 = (Dali::SlotObserver *)jarg1;
16741   arg2 = (Dali::CallbackBase *)jarg2;
16742   {
16743     try {
16744       (arg1)->SlotDisconnected(arg2);
16745     } catch (std::out_of_range& e) {
16746       {
16747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16748       };
16749     } catch (std::exception& e) {
16750       {
16751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16752       };
16753     } catch (...) {
16754       {
16755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16756       };
16757     }
16758   }
16759 }
16760
16761
16762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
16763   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16764
16765   arg1 = (Dali::ConnectionTracker *)jarg1;
16766   {
16767     try {
16768       delete arg1;
16769     } catch (std::out_of_range& e) {
16770       {
16771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16772       };
16773     } catch (std::exception& e) {
16774       {
16775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16776       };
16777     } catch (...) {
16778       {
16779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16780       };
16781     }
16782   }
16783 }
16784
16785
16786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
16787   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16788
16789   arg1 = (Dali::ConnectionTracker *)jarg1;
16790   {
16791     try {
16792       (arg1)->DisconnectAll();
16793     } catch (std::out_of_range& e) {
16794       {
16795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16796       };
16797     } catch (std::exception& e) {
16798       {
16799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16800       };
16801     } catch (...) {
16802       {
16803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16804       };
16805     }
16806   }
16807 }
16808
16809
16810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
16811   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16812   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16813   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16814
16815   arg1 = (Dali::ConnectionTracker *)jarg1;
16816   arg2 = (Dali::SlotObserver *)jarg2;
16817   arg3 = (Dali::CallbackBase *)jarg3;
16818   {
16819     try {
16820       (arg1)->SignalConnected(arg2,arg3);
16821     } catch (std::out_of_range& e) {
16822       {
16823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16824       };
16825     } catch (std::exception& e) {
16826       {
16827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16828       };
16829     } catch (...) {
16830       {
16831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16832       };
16833     }
16834   }
16835 }
16836
16837
16838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
16839   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16840   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
16841   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
16842
16843   arg1 = (Dali::ConnectionTracker *)jarg1;
16844   arg2 = (Dali::SlotObserver *)jarg2;
16845   arg3 = (Dali::CallbackBase *)jarg3;
16846   {
16847     try {
16848       (arg1)->SignalDisconnected(arg2,arg3);
16849     } catch (std::out_of_range& e) {
16850       {
16851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16852       };
16853     } catch (std::exception& e) {
16854       {
16855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16856       };
16857     } catch (...) {
16858       {
16859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16860       };
16861     }
16862   }
16863 }
16864
16865
16866 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
16867   unsigned long jresult ;
16868   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
16869   std::size_t result;
16870
16871   arg1 = (Dali::ConnectionTracker *)jarg1;
16872   {
16873     try {
16874       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
16875     } catch (std::out_of_range& e) {
16876       {
16877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16878       };
16879     } catch (std::exception& e) {
16880       {
16881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16882       };
16883     } catch (...) {
16884       {
16885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16886       };
16887     }
16888   }
16889   jresult = (unsigned long)result;
16890   return jresult;
16891 }
16892
16893
16894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
16895   void * jresult ;
16896   Dali::ObjectRegistry *result = 0 ;
16897
16898   {
16899     try {
16900       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
16901     } catch (std::out_of_range& e) {
16902       {
16903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16904       };
16905     } catch (std::exception& e) {
16906       {
16907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16908       };
16909     } catch (...) {
16910       {
16911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16912       };
16913     }
16914   }
16915   jresult = (void *)result;
16916   return jresult;
16917 }
16918
16919
16920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
16921   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16922
16923   arg1 = (Dali::ObjectRegistry *)jarg1;
16924   {
16925     try {
16926       delete arg1;
16927     } catch (std::out_of_range& e) {
16928       {
16929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16930       };
16931     } catch (std::exception& e) {
16932       {
16933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16934       };
16935     } catch (...) {
16936       {
16937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16938       };
16939     }
16940   }
16941 }
16942
16943
16944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
16945   void * jresult ;
16946   Dali::ObjectRegistry *arg1 = 0 ;
16947   Dali::ObjectRegistry *result = 0 ;
16948
16949   arg1 = (Dali::ObjectRegistry *)jarg1;
16950   if (!arg1) {
16951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16952     return 0;
16953   }
16954   {
16955     try {
16956       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
16957     } catch (std::out_of_range& e) {
16958       {
16959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16960       };
16961     } catch (std::exception& e) {
16962       {
16963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16964       };
16965     } catch (...) {
16966       {
16967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16968       };
16969     }
16970   }
16971   jresult = (void *)result;
16972   return jresult;
16973 }
16974
16975
16976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
16977   void * jresult ;
16978   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
16979   Dali::ObjectRegistry *arg2 = 0 ;
16980   Dali::ObjectRegistry *result = 0 ;
16981
16982   arg1 = (Dali::ObjectRegistry *)jarg1;
16983   arg2 = (Dali::ObjectRegistry *)jarg2;
16984   if (!arg2) {
16985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
16986     return 0;
16987   }
16988   {
16989     try {
16990       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
16991     } catch (std::out_of_range& e) {
16992       {
16993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16994       };
16995     } catch (std::exception& e) {
16996       {
16997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16998       };
16999     } catch (...) {
17000       {
17001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17002       };
17003     }
17004   }
17005   jresult = (void *)result;
17006   return jresult;
17007 }
17008
17009
17010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
17011   void * jresult ;
17012   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17013   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
17014
17015   arg1 = (Dali::ObjectRegistry *)jarg1;
17016   {
17017     try {
17018       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
17019     } catch (std::out_of_range& e) {
17020       {
17021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17022       };
17023     } catch (std::exception& e) {
17024       {
17025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17026       };
17027     } catch (...) {
17028       {
17029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17030       };
17031     }
17032   }
17033   jresult = (void *)result;
17034   return jresult;
17035 }
17036
17037
17038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
17039   void * jresult ;
17040   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
17041   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
17042
17043   arg1 = (Dali::ObjectRegistry *)jarg1;
17044   {
17045     try {
17046       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
17047     } catch (std::out_of_range& e) {
17048       {
17049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17050       };
17051     } catch (std::exception& e) {
17052       {
17053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17054       };
17055     } catch (...) {
17056       {
17057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17058       };
17059     }
17060   }
17061   jresult = (void *)result;
17062   return jresult;
17063 }
17064
17065
17066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
17067   void * jresult ;
17068   Dali::PropertyCondition *result = 0 ;
17069
17070   {
17071     try {
17072       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
17073     } catch (std::out_of_range& e) {
17074       {
17075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17076       };
17077     } catch (std::exception& e) {
17078       {
17079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17080       };
17081     } catch (...) {
17082       {
17083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17084       };
17085     }
17086   }
17087   jresult = (void *)result;
17088   return jresult;
17089 }
17090
17091
17092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
17093   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17094
17095   arg1 = (Dali::PropertyCondition *)jarg1;
17096   {
17097     try {
17098       delete arg1;
17099     } catch (std::out_of_range& e) {
17100       {
17101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17102       };
17103     } catch (std::exception& e) {
17104       {
17105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17106       };
17107     } catch (...) {
17108       {
17109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17110       };
17111     }
17112   }
17113 }
17114
17115
17116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
17117   void * jresult ;
17118   Dali::PropertyCondition *arg1 = 0 ;
17119   Dali::PropertyCondition *result = 0 ;
17120
17121   arg1 = (Dali::PropertyCondition *)jarg1;
17122   if (!arg1) {
17123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17124     return 0;
17125   }
17126   {
17127     try {
17128       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
17129     } catch (std::out_of_range& e) {
17130       {
17131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17132       };
17133     } catch (std::exception& e) {
17134       {
17135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17136       };
17137     } catch (...) {
17138       {
17139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17140       };
17141     }
17142   }
17143   jresult = (void *)result;
17144   return jresult;
17145 }
17146
17147
17148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
17149   void * jresult ;
17150   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17151   Dali::PropertyCondition *arg2 = 0 ;
17152   Dali::PropertyCondition *result = 0 ;
17153
17154   arg1 = (Dali::PropertyCondition *)jarg1;
17155   arg2 = (Dali::PropertyCondition *)jarg2;
17156   if (!arg2) {
17157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
17158     return 0;
17159   }
17160   {
17161     try {
17162       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
17163     } catch (std::out_of_range& e) {
17164       {
17165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17166       };
17167     } catch (std::exception& e) {
17168       {
17169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17170       };
17171     } catch (...) {
17172       {
17173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17174       };
17175     }
17176   }
17177   jresult = (void *)result;
17178   return jresult;
17179 }
17180
17181
17182 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
17183   unsigned long jresult ;
17184   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17185   std::size_t result;
17186
17187   arg1 = (Dali::PropertyCondition *)jarg1;
17188   {
17189     try {
17190       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
17191     } catch (std::out_of_range& e) {
17192       {
17193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17194       };
17195     } catch (std::exception& e) {
17196       {
17197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17198       };
17199     } catch (...) {
17200       {
17201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17202       };
17203     }
17204   }
17205   jresult = (unsigned long)result;
17206   return jresult;
17207 }
17208
17209
17210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
17211   float jresult ;
17212   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
17213   std::size_t arg2 ;
17214   float result;
17215
17216   arg1 = (Dali::PropertyCondition *)jarg1;
17217   arg2 = (std::size_t)jarg2;
17218   {
17219     try {
17220       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
17221     } catch (std::out_of_range& e) {
17222       {
17223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17224       };
17225     } catch (std::exception& e) {
17226       {
17227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17228       };
17229     } catch (...) {
17230       {
17231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17232       };
17233     }
17234   }
17235   jresult = result;
17236   return jresult;
17237 }
17238
17239
17240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
17241   void * jresult ;
17242   float arg1 ;
17243   Dali::PropertyCondition result;
17244
17245   arg1 = (float)jarg1;
17246   {
17247     try {
17248       result = Dali::LessThanCondition(arg1);
17249     } catch (std::out_of_range& e) {
17250       {
17251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17252       };
17253     } catch (std::exception& e) {
17254       {
17255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17256       };
17257     } catch (...) {
17258       {
17259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17260       };
17261     }
17262   }
17263   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17264   return jresult;
17265 }
17266
17267
17268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
17269   void * jresult ;
17270   float arg1 ;
17271   Dali::PropertyCondition result;
17272
17273   arg1 = (float)jarg1;
17274   {
17275     try {
17276       result = Dali::GreaterThanCondition(arg1);
17277     } catch (std::out_of_range& e) {
17278       {
17279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17280       };
17281     } catch (std::exception& e) {
17282       {
17283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17284       };
17285     } catch (...) {
17286       {
17287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17288       };
17289     }
17290   }
17291   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17292   return jresult;
17293 }
17294
17295
17296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
17297   void * jresult ;
17298   float arg1 ;
17299   float arg2 ;
17300   Dali::PropertyCondition result;
17301
17302   arg1 = (float)jarg1;
17303   arg2 = (float)jarg2;
17304   {
17305     try {
17306       result = Dali::InsideCondition(arg1,arg2);
17307     } catch (std::out_of_range& e) {
17308       {
17309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17310       };
17311     } catch (std::exception& e) {
17312       {
17313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17314       };
17315     } catch (...) {
17316       {
17317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17318       };
17319     }
17320   }
17321   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17322   return jresult;
17323 }
17324
17325
17326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
17327   void * jresult ;
17328   float arg1 ;
17329   float arg2 ;
17330   Dali::PropertyCondition result;
17331
17332   arg1 = (float)jarg1;
17333   arg2 = (float)jarg2;
17334   {
17335     try {
17336       result = Dali::OutsideCondition(arg1,arg2);
17337     } catch (std::out_of_range& e) {
17338       {
17339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17340       };
17341     } catch (std::exception& e) {
17342       {
17343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17344       };
17345     } catch (...) {
17346       {
17347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17348       };
17349     }
17350   }
17351   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17352   return jresult;
17353 }
17354
17355
17356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
17357   void * jresult ;
17358   float arg1 ;
17359   float arg2 ;
17360   Dali::PropertyCondition result;
17361
17362   arg1 = (float)jarg1;
17363   arg2 = (float)jarg2;
17364   {
17365     try {
17366       result = Dali::StepCondition(arg1,arg2);
17367     } catch (std::out_of_range& e) {
17368       {
17369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17370       };
17371     } catch (std::exception& e) {
17372       {
17373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17374       };
17375     } catch (...) {
17376       {
17377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17378       };
17379     }
17380   }
17381   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17382   return jresult;
17383 }
17384
17385
17386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
17387   void * jresult ;
17388   float arg1 ;
17389   Dali::PropertyCondition result;
17390
17391   arg1 = (float)jarg1;
17392   {
17393     try {
17394       result = Dali::StepCondition(arg1);
17395     } catch (std::out_of_range& e) {
17396       {
17397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17398       };
17399     } catch (std::exception& e) {
17400       {
17401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17402       };
17403     } catch (...) {
17404       {
17405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17406       };
17407     }
17408   }
17409   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17410   return jresult;
17411 }
17412
17413
17414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
17415   void * jresult ;
17416   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
17417   Dali::PropertyCondition result;
17418
17419   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
17420   if (!arg1) {
17421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
17422     return 0;
17423   }
17424   {
17425     try {
17426       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
17427     } catch (std::out_of_range& e) {
17428       {
17429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17430       };
17431     } catch (std::exception& e) {
17432       {
17433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17434       };
17435     } catch (...) {
17436       {
17437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17438       };
17439     }
17440   }
17441   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17442   return jresult;
17443 }
17444
17445
17446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
17447   void * jresult ;
17448   Dali::PropertyNotification *result = 0 ;
17449
17450   {
17451     try {
17452       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
17453     } catch (std::out_of_range& e) {
17454       {
17455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17456       };
17457     } catch (std::exception& e) {
17458       {
17459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17460       };
17461     } catch (...) {
17462       {
17463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17464       };
17465     }
17466   }
17467   jresult = (void *)result;
17468   return jresult;
17469 }
17470
17471
17472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
17473   void * jresult ;
17474   Dali::BaseHandle arg1 ;
17475   Dali::BaseHandle *argp1 ;
17476   Dali::PropertyNotification result;
17477
17478   argp1 = (Dali::BaseHandle *)jarg1;
17479   if (!argp1) {
17480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17481     return 0;
17482   }
17483   arg1 = *argp1;
17484   {
17485     try {
17486       result = Dali::PropertyNotification::DownCast(arg1);
17487     } catch (std::out_of_range& e) {
17488       {
17489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17490       };
17491     } catch (std::exception& e) {
17492       {
17493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17494       };
17495     } catch (...) {
17496       {
17497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17498       };
17499     }
17500   }
17501   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
17502   return jresult;
17503 }
17504
17505
17506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
17507   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17508
17509   arg1 = (Dali::PropertyNotification *)jarg1;
17510   {
17511     try {
17512       delete arg1;
17513     } catch (std::out_of_range& e) {
17514       {
17515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17516       };
17517     } catch (std::exception& e) {
17518       {
17519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17520       };
17521     } catch (...) {
17522       {
17523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17524       };
17525     }
17526   }
17527 }
17528
17529
17530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
17531   void * jresult ;
17532   Dali::PropertyNotification *arg1 = 0 ;
17533   Dali::PropertyNotification *result = 0 ;
17534
17535   arg1 = (Dali::PropertyNotification *)jarg1;
17536   if (!arg1) {
17537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17538     return 0;
17539   }
17540   {
17541     try {
17542       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
17543     } catch (std::out_of_range& e) {
17544       {
17545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17546       };
17547     } catch (std::exception& e) {
17548       {
17549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17550       };
17551     } catch (...) {
17552       {
17553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17554       };
17555     }
17556   }
17557   jresult = (void *)result;
17558   return jresult;
17559 }
17560
17561
17562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
17563   void * jresult ;
17564   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17565   Dali::PropertyNotification *arg2 = 0 ;
17566   Dali::PropertyNotification *result = 0 ;
17567
17568   arg1 = (Dali::PropertyNotification *)jarg1;
17569   arg2 = (Dali::PropertyNotification *)jarg2;
17570   if (!arg2) {
17571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
17572     return 0;
17573   }
17574   {
17575     try {
17576       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
17577     } catch (std::out_of_range& e) {
17578       {
17579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17580       };
17581     } catch (std::exception& e) {
17582       {
17583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17584       };
17585     } catch (...) {
17586       {
17587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17588       };
17589     }
17590   }
17591   jresult = (void *)result;
17592   return jresult;
17593 }
17594
17595
17596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
17597   void * jresult ;
17598   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17599   Dali::PropertyCondition result;
17600
17601   arg1 = (Dali::PropertyNotification *)jarg1;
17602   {
17603     try {
17604       result = (arg1)->GetCondition();
17605     } catch (std::out_of_range& e) {
17606       {
17607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17608       };
17609     } catch (std::exception& e) {
17610       {
17611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17612       };
17613     } catch (...) {
17614       {
17615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17616       };
17617     }
17618   }
17619   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
17620   return jresult;
17621 }
17622
17623
17624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
17625   void * jresult ;
17626   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17627   Dali::Handle result;
17628
17629   arg1 = (Dali::PropertyNotification *)jarg1;
17630   {
17631     try {
17632       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
17633     } catch (std::out_of_range& e) {
17634       {
17635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17636       };
17637     } catch (std::exception& e) {
17638       {
17639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17640       };
17641     } catch (...) {
17642       {
17643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17644       };
17645     }
17646   }
17647   jresult = new Dali::Handle((const Dali::Handle &)result);
17648   return jresult;
17649 }
17650
17651
17652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
17653   int jresult ;
17654   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17655   Dali::Property::Index result;
17656
17657   arg1 = (Dali::PropertyNotification *)jarg1;
17658   {
17659     try {
17660       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
17661     } catch (std::out_of_range& e) {
17662       {
17663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17664       };
17665     } catch (std::exception& e) {
17666       {
17667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17668       };
17669     } catch (...) {
17670       {
17671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17672       };
17673     }
17674   }
17675   jresult = result;
17676   return jresult;
17677 }
17678
17679
17680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
17681   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17682   Dali::PropertyNotification::NotifyMode arg2 ;
17683
17684   arg1 = (Dali::PropertyNotification *)jarg1;
17685   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
17686   {
17687     try {
17688       (arg1)->SetNotifyMode(arg2);
17689     } catch (std::out_of_range& e) {
17690       {
17691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17692       };
17693     } catch (std::exception& e) {
17694       {
17695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17696       };
17697     } catch (...) {
17698       {
17699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17700       };
17701     }
17702   }
17703 }
17704
17705
17706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
17707   int jresult ;
17708   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17709   Dali::PropertyNotification::NotifyMode result;
17710
17711   arg1 = (Dali::PropertyNotification *)jarg1;
17712   {
17713     try {
17714       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
17715     } catch (std::out_of_range& e) {
17716       {
17717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17718       };
17719     } catch (std::exception& e) {
17720       {
17721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17722       };
17723     } catch (...) {
17724       {
17725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17726       };
17727     }
17728   }
17729   jresult = (int)result;
17730   return jresult;
17731 }
17732
17733
17734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
17735   unsigned int jresult ;
17736   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17737   bool result;
17738
17739   arg1 = (Dali::PropertyNotification *)jarg1;
17740   {
17741     try {
17742       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
17743     } catch (std::out_of_range& e) {
17744       {
17745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (std::exception& e) {
17748       {
17749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17750       };
17751     } catch (...) {
17752       {
17753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17754       };
17755     }
17756   }
17757   jresult = result;
17758   return jresult;
17759 }
17760
17761
17762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
17763   void * jresult ;
17764   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
17765   Dali::PropertyNotifySignalType *result = 0 ;
17766
17767   arg1 = (Dali::PropertyNotification *)jarg1;
17768   {
17769     try {
17770       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
17771     } catch (std::out_of_range& e) {
17772       {
17773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17774       };
17775     } catch (std::exception& e) {
17776       {
17777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17778       };
17779     } catch (...) {
17780       {
17781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17782       };
17783     }
17784   }
17785   jresult = (void *)result;
17786   return jresult;
17787 }
17788
17789
17790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
17791   void * jresult ;
17792   Dali::Handle *result = 0 ;
17793
17794   {
17795     try {
17796       result = (Dali::Handle *)new Dali::Handle();
17797     } catch (std::out_of_range& e) {
17798       {
17799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17800       };
17801     } catch (std::exception& e) {
17802       {
17803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17804       };
17805     } catch (...) {
17806       {
17807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17808       };
17809     }
17810   }
17811   jresult = (void *)result;
17812   return jresult;
17813 }
17814
17815
17816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
17817   void * jresult ;
17818   Dali::Handle result;
17819
17820   {
17821     try {
17822       result = Dali::Handle::New();
17823     } catch (std::out_of_range& e) {
17824       {
17825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17826       };
17827     } catch (std::exception& e) {
17828       {
17829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17830       };
17831     } catch (...) {
17832       {
17833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17834       };
17835     }
17836   }
17837   jresult = new Dali::Handle((const Dali::Handle &)result);
17838   return jresult;
17839 }
17840
17841
17842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
17843   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17844
17845   arg1 = (Dali::Handle *)jarg1;
17846   {
17847     try {
17848       delete arg1;
17849     } catch (std::out_of_range& e) {
17850       {
17851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17852       };
17853     } catch (std::exception& e) {
17854       {
17855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17856       };
17857     } catch (...) {
17858       {
17859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17860       };
17861     }
17862   }
17863 }
17864
17865
17866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
17867   void * jresult ;
17868   Dali::Handle *arg1 = 0 ;
17869   Dali::Handle *result = 0 ;
17870
17871   arg1 = (Dali::Handle *)jarg1;
17872   if (!arg1) {
17873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17874     return 0;
17875   }
17876   {
17877     try {
17878       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
17879     } catch (std::out_of_range& e) {
17880       {
17881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17882       };
17883     } catch (std::exception& e) {
17884       {
17885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17886       };
17887     } catch (...) {
17888       {
17889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17890       };
17891     }
17892   }
17893   jresult = (void *)result;
17894   return jresult;
17895 }
17896
17897
17898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
17899   void * jresult ;
17900   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17901   Dali::Handle *arg2 = 0 ;
17902   Dali::Handle *result = 0 ;
17903
17904   arg1 = (Dali::Handle *)jarg1;
17905   arg2 = (Dali::Handle *)jarg2;
17906   if (!arg2) {
17907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
17908     return 0;
17909   }
17910   {
17911     try {
17912       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
17913     } catch (std::out_of_range& e) {
17914       {
17915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17916       };
17917     } catch (std::exception& e) {
17918       {
17919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17920       };
17921     } catch (...) {
17922       {
17923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17924       };
17925     }
17926   }
17927   jresult = (void *)result;
17928   return jresult;
17929 }
17930
17931
17932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
17933   void * jresult ;
17934   Dali::BaseHandle arg1 ;
17935   Dali::BaseHandle *argp1 ;
17936   Dali::Handle result;
17937
17938   argp1 = (Dali::BaseHandle *)jarg1;
17939   if (!argp1) {
17940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
17941     return 0;
17942   }
17943   arg1 = *argp1;
17944   {
17945     try {
17946       result = Dali::Handle::DownCast(arg1);
17947     } catch (std::out_of_range& e) {
17948       {
17949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17950       };
17951     } catch (std::exception& e) {
17952       {
17953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17954       };
17955     } catch (...) {
17956       {
17957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17958       };
17959     }
17960   }
17961   jresult = new Dali::Handle((const Dali::Handle &)result);
17962   return jresult;
17963 }
17964
17965
17966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
17967   unsigned int jresult ;
17968   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17969   Dali::Handle::Capability arg2 ;
17970   bool result;
17971
17972   arg1 = (Dali::Handle *)jarg1;
17973   arg2 = (Dali::Handle::Capability)jarg2;
17974   {
17975     try {
17976       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
17977     } catch (std::out_of_range& e) {
17978       {
17979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17980       };
17981     } catch (std::exception& e) {
17982       {
17983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17984       };
17985     } catch (...) {
17986       {
17987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17988       };
17989     }
17990   }
17991   jresult = result;
17992   return jresult;
17993 }
17994
17995
17996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
17997   unsigned int jresult ;
17998   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
17999   unsigned int result;
18000
18001   arg1 = (Dali::Handle *)jarg1;
18002   {
18003     try {
18004       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
18005     } catch (std::out_of_range& e) {
18006       {
18007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18008       };
18009     } catch (std::exception& e) {
18010       {
18011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18012       };
18013     } catch (...) {
18014       {
18015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18016       };
18017     }
18018   }
18019   jresult = result;
18020   return jresult;
18021 }
18022
18023
18024 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
18025   char * jresult ;
18026   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18027   Dali::Property::Index arg2 ;
18028   std::string result;
18029
18030   arg1 = (Dali::Handle *)jarg1;
18031   arg2 = (Dali::Property::Index)jarg2;
18032   {
18033     try {
18034       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
18035     } catch (std::out_of_range& e) {
18036       {
18037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18038       };
18039     } catch (std::exception& e) {
18040       {
18041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18042       };
18043     } catch (...) {
18044       {
18045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18046       };
18047     }
18048   }
18049   jresult = SWIG_csharp_string_callback((&result)->c_str());
18050   return jresult;
18051 }
18052
18053
18054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
18055   int jresult ;
18056   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18057   std::string *arg2 = 0 ;
18058   Dali::Property::Index result;
18059
18060   arg1 = (Dali::Handle *)jarg1;
18061   if (!jarg2) {
18062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18063     return 0;
18064   }
18065   std::string arg2_str(jarg2);
18066   arg2 = &arg2_str;
18067   {
18068     try {
18069       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
18070     } catch (std::out_of_range& e) {
18071       {
18072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18073       };
18074     } catch (std::exception& e) {
18075       {
18076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18077       };
18078     } catch (...) {
18079       {
18080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18081       };
18082     }
18083   }
18084   jresult = result;
18085
18086   //argout typemap for const std::string&
18087
18088   return jresult;
18089 }
18090
18091
18092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
18093   unsigned int jresult ;
18094   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18095   Dali::Property::Index arg2 ;
18096   bool result;
18097
18098   arg1 = (Dali::Handle *)jarg1;
18099   arg2 = (Dali::Property::Index)jarg2;
18100   {
18101     try {
18102       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
18103     } catch (std::out_of_range& e) {
18104       {
18105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18106       };
18107     } catch (std::exception& e) {
18108       {
18109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18110       };
18111     } catch (...) {
18112       {
18113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18114       };
18115     }
18116   }
18117   jresult = result;
18118   return jresult;
18119 }
18120
18121
18122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
18123   unsigned int jresult ;
18124   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18125   Dali::Property::Index arg2 ;
18126   bool result;
18127
18128   arg1 = (Dali::Handle *)jarg1;
18129   arg2 = (Dali::Property::Index)jarg2;
18130   {
18131     try {
18132       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
18133     } catch (std::out_of_range& e) {
18134       {
18135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18136       };
18137     } catch (std::exception& e) {
18138       {
18139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18140       };
18141     } catch (...) {
18142       {
18143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18144       };
18145     }
18146   }
18147   jresult = result;
18148   return jresult;
18149 }
18150
18151
18152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
18153   unsigned int jresult ;
18154   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18155   Dali::Property::Index arg2 ;
18156   bool result;
18157
18158   arg1 = (Dali::Handle *)jarg1;
18159   arg2 = (Dali::Property::Index)jarg2;
18160   {
18161     try {
18162       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
18163     } catch (std::out_of_range& e) {
18164       {
18165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18166       };
18167     } catch (std::exception& e) {
18168       {
18169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18170       };
18171     } catch (...) {
18172       {
18173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18174       };
18175     }
18176   }
18177   jresult = result;
18178   return jresult;
18179 }
18180
18181
18182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
18183   int jresult ;
18184   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18185   Dali::Property::Index arg2 ;
18186   Dali::Property::Type result;
18187
18188   arg1 = (Dali::Handle *)jarg1;
18189   arg2 = (Dali::Property::Index)jarg2;
18190   {
18191     try {
18192       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
18193     } catch (std::out_of_range& e) {
18194       {
18195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18196       };
18197     } catch (std::exception& e) {
18198       {
18199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18200       };
18201     } catch (...) {
18202       {
18203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18204       };
18205     }
18206   }
18207   jresult = (int)result;
18208   return jresult;
18209 }
18210
18211
18212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
18213   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18214   Dali::Property::Index arg2 ;
18215   Dali::Property::Value *arg3 = 0 ;
18216
18217   arg1 = (Dali::Handle *)jarg1;
18218   arg2 = (Dali::Property::Index)jarg2;
18219   arg3 = (Dali::Property::Value *)jarg3;
18220   if (!arg3) {
18221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18222     return ;
18223   }
18224   {
18225     try {
18226       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
18227     } catch (std::out_of_range& e) {
18228       {
18229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18230       };
18231     } catch (std::exception& e) {
18232       {
18233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18234       };
18235     } catch (...) {
18236       {
18237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18238       };
18239     }
18240   }
18241 }
18242
18243
18244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
18245   int jresult ;
18246   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18247   std::string *arg2 = 0 ;
18248   Dali::Property::Value *arg3 = 0 ;
18249   Dali::Property::Index result;
18250
18251   arg1 = (Dali::Handle *)jarg1;
18252   if (!jarg2) {
18253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18254     return 0;
18255   }
18256   std::string arg2_str(jarg2);
18257   arg2 = &arg2_str;
18258   arg3 = (Dali::Property::Value *)jarg3;
18259   if (!arg3) {
18260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18261     return 0;
18262   }
18263   {
18264     try {
18265       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
18266     } catch (std::out_of_range& e) {
18267       {
18268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18269       };
18270     } catch (std::exception& e) {
18271       {
18272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18273       };
18274     } catch (...) {
18275       {
18276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18277       };
18278     }
18279   }
18280   jresult = result;
18281
18282   //argout typemap for const std::string&
18283
18284   return jresult;
18285 }
18286
18287
18288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
18289   int jresult ;
18290   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18291   std::string *arg2 = 0 ;
18292   Dali::Property::Value *arg3 = 0 ;
18293   Dali::Property::AccessMode arg4 ;
18294   Dali::Property::Index result;
18295
18296   arg1 = (Dali::Handle *)jarg1;
18297   if (!jarg2) {
18298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18299     return 0;
18300   }
18301   std::string arg2_str(jarg2);
18302   arg2 = &arg2_str;
18303   arg3 = (Dali::Property::Value *)jarg3;
18304   if (!arg3) {
18305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
18306     return 0;
18307   }
18308   arg4 = (Dali::Property::AccessMode)jarg4;
18309   {
18310     try {
18311       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
18312     } catch (std::out_of_range& e) {
18313       {
18314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18315       };
18316     } catch (std::exception& e) {
18317       {
18318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18319       };
18320     } catch (...) {
18321       {
18322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18323       };
18324     }
18325   }
18326   jresult = result;
18327
18328   //argout typemap for const std::string&
18329
18330   return jresult;
18331 }
18332
18333
18334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
18335   void * jresult ;
18336   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18337   Dali::Property::Index arg2 ;
18338   Dali::Property::Value result;
18339
18340   arg1 = (Dali::Handle *)jarg1;
18341   arg2 = (Dali::Property::Index)jarg2;
18342   {
18343     try {
18344       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
18345     } catch (std::out_of_range& e) {
18346       {
18347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18348       };
18349     } catch (std::exception& e) {
18350       {
18351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18352       };
18353     } catch (...) {
18354       {
18355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18356       };
18357     }
18358   }
18359   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
18360   return jresult;
18361 }
18362
18363
18364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
18365   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18366   Dali::Property::IndexContainer *arg2 = 0 ;
18367
18368   arg1 = (Dali::Handle *)jarg1;
18369   arg2 = (Dali::Property::IndexContainer *)jarg2;
18370   if (!arg2) {
18371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18372     return ;
18373   }
18374   {
18375     try {
18376       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
18377     } catch (std::out_of_range& e) {
18378       {
18379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18380       };
18381     } catch (std::exception& e) {
18382       {
18383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18384       };
18385     } catch (...) {
18386       {
18387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18388       };
18389     }
18390   }
18391 }
18392
18393
18394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
18395   void * jresult ;
18396   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18397   Dali::Property::Index arg2 ;
18398   Dali::PropertyCondition *arg3 = 0 ;
18399   Dali::PropertyNotification result;
18400
18401   arg1 = (Dali::Handle *)jarg1;
18402   arg2 = (Dali::Property::Index)jarg2;
18403   arg3 = (Dali::PropertyCondition *)jarg3;
18404   if (!arg3) {
18405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18406     return 0;
18407   }
18408   {
18409     try {
18410       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
18411     } catch (std::out_of_range& e) {
18412       {
18413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18414       };
18415     } catch (std::exception& e) {
18416       {
18417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18418       };
18419     } catch (...) {
18420       {
18421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18422       };
18423     }
18424   }
18425   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18426   return jresult;
18427 }
18428
18429
18430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
18431   void * jresult ;
18432   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18433   Dali::Property::Index arg2 ;
18434   int arg3 ;
18435   Dali::PropertyCondition *arg4 = 0 ;
18436   Dali::PropertyNotification result;
18437
18438   arg1 = (Dali::Handle *)jarg1;
18439   arg2 = (Dali::Property::Index)jarg2;
18440   arg3 = (int)jarg3;
18441   arg4 = (Dali::PropertyCondition *)jarg4;
18442   if (!arg4) {
18443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
18444     return 0;
18445   }
18446   {
18447     try {
18448       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
18449     } catch (std::out_of_range& e) {
18450       {
18451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18452       };
18453     } catch (std::exception& e) {
18454       {
18455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18456       };
18457     } catch (...) {
18458       {
18459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18460       };
18461     }
18462   }
18463   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
18464   return jresult;
18465 }
18466
18467
18468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
18469   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18470   Dali::PropertyNotification arg2 ;
18471   Dali::PropertyNotification *argp2 ;
18472
18473   arg1 = (Dali::Handle *)jarg1;
18474   argp2 = (Dali::PropertyNotification *)jarg2;
18475   if (!argp2) {
18476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
18477     return ;
18478   }
18479   arg2 = *argp2;
18480   {
18481     try {
18482       (arg1)->RemovePropertyNotification(arg2);
18483     } catch (std::out_of_range& e) {
18484       {
18485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18486       };
18487     } catch (std::exception& e) {
18488       {
18489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18490       };
18491     } catch (...) {
18492       {
18493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18494       };
18495     }
18496   }
18497 }
18498
18499
18500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
18501   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18502
18503   arg1 = (Dali::Handle *)jarg1;
18504   {
18505     try {
18506       (arg1)->RemovePropertyNotifications();
18507     } catch (std::out_of_range& e) {
18508       {
18509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18510       };
18511     } catch (std::exception& e) {
18512       {
18513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18514       };
18515     } catch (...) {
18516       {
18517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18518       };
18519     }
18520   }
18521 }
18522
18523
18524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
18525   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18526
18527   arg1 = (Dali::Handle *)jarg1;
18528   {
18529     try {
18530       (arg1)->RemoveConstraints();
18531     } catch (std::out_of_range& e) {
18532       {
18533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18534       };
18535     } catch (std::exception& e) {
18536       {
18537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18538       };
18539     } catch (...) {
18540       {
18541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18542       };
18543     }
18544   }
18545 }
18546
18547
18548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
18549   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
18550   unsigned int arg2 ;
18551
18552   arg1 = (Dali::Handle *)jarg1;
18553   arg2 = (unsigned int)jarg2;
18554   {
18555     try {
18556       (arg1)->RemoveConstraints(arg2);
18557     } catch (std::out_of_range& e) {
18558       {
18559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18560       };
18561     } catch (std::exception& e) {
18562       {
18563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18564       };
18565     } catch (...) {
18566       {
18567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18568       };
18569     }
18570   }
18571 }
18572
18573
18574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
18575   int jresult ;
18576   Dali::Property::Index result;
18577
18578   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
18579   jresult = result;
18580   return jresult;
18581 }
18582
18583
18584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
18585   void * jresult ;
18586   Dali::Handle result;
18587
18588   {
18589     try {
18590       result = Dali::WeightObject::New();
18591     } catch (std::out_of_range& e) {
18592       {
18593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18594       };
18595     } catch (std::exception& e) {
18596       {
18597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18598       };
18599     } catch (...) {
18600       {
18601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18602       };
18603     }
18604   }
18605   jresult = new Dali::Handle((const Dali::Handle &)result);
18606   return jresult;
18607 }
18608
18609
18610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
18611   void * jresult ;
18612   Dali::TypeInfo *result = 0 ;
18613
18614   {
18615     try {
18616       result = (Dali::TypeInfo *)new Dali::TypeInfo();
18617     } catch (std::out_of_range& e) {
18618       {
18619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18620       };
18621     } catch (std::exception& e) {
18622       {
18623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18624       };
18625     } catch (...) {
18626       {
18627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18628       };
18629     }
18630   }
18631   jresult = (void *)result;
18632   return jresult;
18633 }
18634
18635
18636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
18637   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18638
18639   arg1 = (Dali::TypeInfo *)jarg1;
18640   {
18641     try {
18642       delete arg1;
18643     } catch (std::out_of_range& e) {
18644       {
18645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18646       };
18647     } catch (std::exception& e) {
18648       {
18649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18650       };
18651     } catch (...) {
18652       {
18653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18654       };
18655     }
18656   }
18657 }
18658
18659
18660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
18661   void * jresult ;
18662   Dali::TypeInfo *arg1 = 0 ;
18663   Dali::TypeInfo *result = 0 ;
18664
18665   arg1 = (Dali::TypeInfo *)jarg1;
18666   if (!arg1) {
18667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18668     return 0;
18669   }
18670   {
18671     try {
18672       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
18673     } catch (std::out_of_range& e) {
18674       {
18675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18676       };
18677     } catch (std::exception& e) {
18678       {
18679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18680       };
18681     } catch (...) {
18682       {
18683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18684       };
18685     }
18686   }
18687   jresult = (void *)result;
18688   return jresult;
18689 }
18690
18691
18692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
18693   void * jresult ;
18694   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18695   Dali::TypeInfo *arg2 = 0 ;
18696   Dali::TypeInfo *result = 0 ;
18697
18698   arg1 = (Dali::TypeInfo *)jarg1;
18699   arg2 = (Dali::TypeInfo *)jarg2;
18700   if (!arg2) {
18701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
18702     return 0;
18703   }
18704   {
18705     try {
18706       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
18707     } catch (std::out_of_range& e) {
18708       {
18709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18710       };
18711     } catch (std::exception& e) {
18712       {
18713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18714       };
18715     } catch (...) {
18716       {
18717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18718       };
18719     }
18720   }
18721   jresult = (void *)result;
18722   return jresult;
18723 }
18724
18725
18726 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
18727   char * jresult ;
18728   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18729   std::string *result = 0 ;
18730
18731   arg1 = (Dali::TypeInfo *)jarg1;
18732   {
18733     try {
18734       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
18735     } catch (std::out_of_range& e) {
18736       {
18737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18738       };
18739     } catch (std::exception& e) {
18740       {
18741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18742       };
18743     } catch (...) {
18744       {
18745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18746       };
18747     }
18748   }
18749   jresult = SWIG_csharp_string_callback(result->c_str());
18750   return jresult;
18751 }
18752
18753
18754 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
18755   char * jresult ;
18756   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18757   std::string *result = 0 ;
18758
18759   arg1 = (Dali::TypeInfo *)jarg1;
18760   {
18761     try {
18762       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
18763     } catch (std::out_of_range& e) {
18764       {
18765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18766       };
18767     } catch (std::exception& e) {
18768       {
18769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18770       };
18771     } catch (...) {
18772       {
18773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18774       };
18775     }
18776   }
18777   jresult = SWIG_csharp_string_callback(result->c_str());
18778   return jresult;
18779 }
18780
18781
18782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
18783   void * jresult ;
18784   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18785   Dali::BaseHandle result;
18786
18787   arg1 = (Dali::TypeInfo *)jarg1;
18788   {
18789     try {
18790       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
18791     } catch (std::out_of_range& e) {
18792       {
18793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18794       };
18795     } catch (std::exception& e) {
18796       {
18797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18798       };
18799     } catch (...) {
18800       {
18801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18802       };
18803     }
18804   }
18805   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
18806   return jresult;
18807 }
18808
18809
18810 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
18811   unsigned long jresult ;
18812   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18813   size_t result;
18814
18815   arg1 = (Dali::TypeInfo *)jarg1;
18816   {
18817     try {
18818       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
18819     } catch (std::out_of_range& e) {
18820       {
18821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18822       };
18823     } catch (std::exception& e) {
18824       {
18825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18826       };
18827     } catch (...) {
18828       {
18829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18830       };
18831     }
18832   }
18833   jresult = (unsigned long)result;
18834   return jresult;
18835 }
18836
18837
18838 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
18839   char * jresult ;
18840   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18841   size_t arg2 ;
18842   std::string result;
18843
18844   arg1 = (Dali::TypeInfo *)jarg1;
18845   arg2 = (size_t)jarg2;
18846   {
18847     try {
18848       result = (arg1)->GetActionName(arg2);
18849     } catch (std::out_of_range& e) {
18850       {
18851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18852       };
18853     } catch (std::exception& e) {
18854       {
18855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18856       };
18857     } catch (...) {
18858       {
18859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18860       };
18861     }
18862   }
18863   jresult = SWIG_csharp_string_callback((&result)->c_str());
18864   return jresult;
18865 }
18866
18867
18868 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
18869   unsigned long jresult ;
18870   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18871   size_t result;
18872
18873   arg1 = (Dali::TypeInfo *)jarg1;
18874   {
18875     try {
18876       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
18877     } catch (std::out_of_range& e) {
18878       {
18879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18880       };
18881     } catch (std::exception& e) {
18882       {
18883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18884       };
18885     } catch (...) {
18886       {
18887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18888       };
18889     }
18890   }
18891   jresult = (unsigned long)result;
18892   return jresult;
18893 }
18894
18895
18896 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
18897   char * jresult ;
18898   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18899   size_t arg2 ;
18900   std::string result;
18901
18902   arg1 = (Dali::TypeInfo *)jarg1;
18903   arg2 = (size_t)jarg2;
18904   {
18905     try {
18906       result = (arg1)->GetSignalName(arg2);
18907     } catch (std::out_of_range& e) {
18908       {
18909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18910       };
18911     } catch (std::exception& e) {
18912       {
18913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18914       };
18915     } catch (...) {
18916       {
18917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18918       };
18919     }
18920   }
18921   jresult = SWIG_csharp_string_callback((&result)->c_str());
18922   return jresult;
18923 }
18924
18925
18926 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
18927   unsigned long jresult ;
18928   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18929   size_t result;
18930
18931   arg1 = (Dali::TypeInfo *)jarg1;
18932   {
18933     try {
18934       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
18935     } catch (std::out_of_range& e) {
18936       {
18937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18938       };
18939     } catch (std::exception& e) {
18940       {
18941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18942       };
18943     } catch (...) {
18944       {
18945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18946       };
18947     }
18948   }
18949   jresult = (unsigned long)result;
18950   return jresult;
18951 }
18952
18953
18954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
18955   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18956   Dali::Property::IndexContainer *arg2 = 0 ;
18957
18958   arg1 = (Dali::TypeInfo *)jarg1;
18959   arg2 = (Dali::Property::IndexContainer *)jarg2;
18960   if (!arg2) {
18961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
18962     return ;
18963   }
18964   {
18965     try {
18966       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
18967     } catch (std::out_of_range& e) {
18968       {
18969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18970       };
18971     } catch (std::exception& e) {
18972       {
18973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18974       };
18975     } catch (...) {
18976       {
18977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18978       };
18979     }
18980   }
18981 }
18982
18983
18984 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
18985   char * jresult ;
18986   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
18987   Dali::Property::Index arg2 ;
18988   std::string *result = 0 ;
18989
18990   arg1 = (Dali::TypeInfo *)jarg1;
18991   arg2 = (Dali::Property::Index)jarg2;
18992   {
18993     try {
18994       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
18995     } catch (std::out_of_range& e) {
18996       {
18997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18998       };
18999     } catch (std::exception& e) {
19000       {
19001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19002       };
19003     } catch (...) {
19004       {
19005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19006       };
19007     }
19008   }
19009   jresult = SWIG_csharp_string_callback(result->c_str());
19010   return jresult;
19011 }
19012
19013
19014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
19015   void * jresult ;
19016   Dali::TypeRegistry result;
19017
19018   {
19019     try {
19020       result = Dali::TypeRegistry::Get();
19021     } catch (std::out_of_range& e) {
19022       {
19023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19024       };
19025     } catch (std::exception& e) {
19026       {
19027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19028       };
19029     } catch (...) {
19030       {
19031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19032       };
19033     }
19034   }
19035   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
19036   return jresult;
19037 }
19038
19039
19040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
19041   void * jresult ;
19042   Dali::TypeRegistry *result = 0 ;
19043
19044   {
19045     try {
19046       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
19047     } catch (std::out_of_range& e) {
19048       {
19049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19050       };
19051     } catch (std::exception& e) {
19052       {
19053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19054       };
19055     } catch (...) {
19056       {
19057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19058       };
19059     }
19060   }
19061   jresult = (void *)result;
19062   return jresult;
19063 }
19064
19065
19066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
19067   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19068
19069   arg1 = (Dali::TypeRegistry *)jarg1;
19070   {
19071     try {
19072       delete arg1;
19073     } catch (std::out_of_range& e) {
19074       {
19075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19076       };
19077     } catch (std::exception& e) {
19078       {
19079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19080       };
19081     } catch (...) {
19082       {
19083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19084       };
19085     }
19086   }
19087 }
19088
19089
19090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
19091   void * jresult ;
19092   Dali::TypeRegistry *arg1 = 0 ;
19093   Dali::TypeRegistry *result = 0 ;
19094
19095   arg1 = (Dali::TypeRegistry *)jarg1;
19096   if (!arg1) {
19097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19098     return 0;
19099   }
19100   {
19101     try {
19102       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
19103     } catch (std::out_of_range& e) {
19104       {
19105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19106       };
19107     } catch (std::exception& e) {
19108       {
19109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19110       };
19111     } catch (...) {
19112       {
19113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19114       };
19115     }
19116   }
19117   jresult = (void *)result;
19118   return jresult;
19119 }
19120
19121
19122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
19123   void * jresult ;
19124   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19125   Dali::TypeRegistry *arg2 = 0 ;
19126   Dali::TypeRegistry *result = 0 ;
19127
19128   arg1 = (Dali::TypeRegistry *)jarg1;
19129   arg2 = (Dali::TypeRegistry *)jarg2;
19130   if (!arg2) {
19131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
19132     return 0;
19133   }
19134   {
19135     try {
19136       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
19137     } catch (std::out_of_range& e) {
19138       {
19139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19140       };
19141     } catch (std::exception& e) {
19142       {
19143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19144       };
19145     } catch (...) {
19146       {
19147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19148       };
19149     }
19150   }
19151   jresult = (void *)result;
19152   return jresult;
19153 }
19154
19155
19156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
19157   void * jresult ;
19158   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19159   std::string *arg2 = 0 ;
19160   Dali::TypeInfo result;
19161
19162   arg1 = (Dali::TypeRegistry *)jarg1;
19163   if (!jarg2) {
19164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19165     return 0;
19166   }
19167   std::string arg2_str(jarg2);
19168   arg2 = &arg2_str;
19169   {
19170     try {
19171       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
19172     } catch (std::out_of_range& e) {
19173       {
19174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19175       };
19176     } catch (std::exception& e) {
19177       {
19178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19179       };
19180     } catch (...) {
19181       {
19182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19183       };
19184     }
19185   }
19186   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19187
19188   //argout typemap for const std::string&
19189
19190   return jresult;
19191 }
19192
19193
19194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
19195   void * jresult ;
19196   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19197   std::type_info *arg2 = 0 ;
19198   Dali::TypeInfo result;
19199
19200   arg1 = (Dali::TypeRegistry *)jarg1;
19201   arg2 = (std::type_info *)jarg2;
19202   if (!arg2) {
19203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19204     return 0;
19205   }
19206   {
19207     try {
19208       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
19209     } catch (std::out_of_range& e) {
19210       {
19211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19212       };
19213     } catch (std::exception& e) {
19214       {
19215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19216       };
19217     } catch (...) {
19218       {
19219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19220       };
19221     }
19222   }
19223   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
19224   return jresult;
19225 }
19226
19227
19228 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
19229   unsigned long jresult ;
19230   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19231   size_t result;
19232
19233   arg1 = (Dali::TypeRegistry *)jarg1;
19234   {
19235     try {
19236       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
19237     } catch (std::out_of_range& e) {
19238       {
19239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19240       };
19241     } catch (std::exception& e) {
19242       {
19243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19244       };
19245     } catch (...) {
19246       {
19247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19248       };
19249     }
19250   }
19251   jresult = (unsigned long)result;
19252   return jresult;
19253 }
19254
19255
19256 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
19257   char * jresult ;
19258   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
19259   size_t arg2 ;
19260   std::string result;
19261
19262   arg1 = (Dali::TypeRegistry *)jarg1;
19263   arg2 = (size_t)jarg2;
19264   {
19265     try {
19266       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
19267     } catch (std::out_of_range& e) {
19268       {
19269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19270       };
19271     } catch (std::exception& e) {
19272       {
19273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19274       };
19275     } catch (...) {
19276       {
19277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19278       };
19279     }
19280   }
19281   jresult = SWIG_csharp_string_callback((&result)->c_str());
19282   return jresult;
19283 }
19284
19285
19286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
19287   void * jresult ;
19288   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
19289   Dali::TypeRegistry *result = 0 ;
19290
19291   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
19292   {
19293     try {
19294       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
19295     } catch (std::out_of_range& e) {
19296       {
19297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19298       };
19299     } catch (std::exception& e) {
19300       {
19301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19302       };
19303     } catch (...) {
19304       {
19305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19306       };
19307     }
19308   }
19309   jresult = (void *)result;
19310   return jresult;
19311 }
19312
19313
19314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
19315   void * jresult ;
19316   std::type_info *arg1 = 0 ;
19317   std::type_info *arg2 = 0 ;
19318   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19319   Dali::TypeRegistration *result = 0 ;
19320
19321   arg1 = (std::type_info *)jarg1;
19322   if (!arg1) {
19323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19324     return 0;
19325   }
19326   arg2 = (std::type_info *)jarg2;
19327   if (!arg2) {
19328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19329     return 0;
19330   }
19331   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19332   {
19333     try {
19334       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
19335     } catch (std::out_of_range& e) {
19336       {
19337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19338       };
19339     } catch (std::exception& e) {
19340       {
19341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19342       };
19343     } catch (...) {
19344       {
19345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19346       };
19347     }
19348   }
19349   jresult = (void *)result;
19350   return jresult;
19351 }
19352
19353
19354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
19355   void * jresult ;
19356   std::type_info *arg1 = 0 ;
19357   std::type_info *arg2 = 0 ;
19358   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19359   bool arg4 ;
19360   Dali::TypeRegistration *result = 0 ;
19361
19362   arg1 = (std::type_info *)jarg1;
19363   if (!arg1) {
19364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19365     return 0;
19366   }
19367   arg2 = (std::type_info *)jarg2;
19368   if (!arg2) {
19369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19370     return 0;
19371   }
19372   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19373   arg4 = jarg4 ? true : false;
19374   {
19375     try {
19376       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
19377     } catch (std::out_of_range& e) {
19378       {
19379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19380       };
19381     } catch (std::exception& e) {
19382       {
19383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19384       };
19385     } catch (...) {
19386       {
19387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19388       };
19389     }
19390   }
19391   jresult = (void *)result;
19392   return jresult;
19393 }
19394
19395
19396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
19397   void * jresult ;
19398   std::string *arg1 = 0 ;
19399   std::type_info *arg2 = 0 ;
19400   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
19401   Dali::TypeRegistration *result = 0 ;
19402
19403   if (!jarg1) {
19404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19405     return 0;
19406   }
19407   std::string arg1_str(jarg1);
19408   arg1 = &arg1_str;
19409   arg2 = (std::type_info *)jarg2;
19410   if (!arg2) {
19411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
19412     return 0;
19413   }
19414   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
19415   {
19416     try {
19417       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
19418     } catch (std::out_of_range& e) {
19419       {
19420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19421       };
19422     } catch (std::exception& e) {
19423       {
19424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19425       };
19426     } catch (...) {
19427       {
19428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19429       };
19430     }
19431   }
19432   jresult = (void *)result;
19433
19434   //argout typemap for const std::string&
19435
19436   return jresult;
19437 }
19438
19439
19440 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
19441   char * jresult ;
19442   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19443   std::string result;
19444
19445   arg1 = (Dali::TypeRegistration *)jarg1;
19446   {
19447     try {
19448       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
19449     } catch (std::out_of_range& e) {
19450       {
19451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19452       };
19453     } catch (std::exception& e) {
19454       {
19455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19456       };
19457     } catch (...) {
19458       {
19459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19460       };
19461     }
19462   }
19463   jresult = SWIG_csharp_string_callback((&result)->c_str());
19464   return jresult;
19465 }
19466
19467
19468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
19469   std::string *arg1 = 0 ;
19470   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
19471
19472   if (!jarg1) {
19473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19474     return ;
19475   }
19476   std::string arg1_str(jarg1);
19477   arg1 = &arg1_str;
19478   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
19479   {
19480     try {
19481       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
19482     } catch (std::out_of_range& e) {
19483       {
19484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19485       };
19486     } catch (std::exception& e) {
19487       {
19488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19489       };
19490     } catch (...) {
19491       {
19492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19493       };
19494     }
19495   }
19496
19497   //argout typemap for const std::string&
19498
19499 }
19500
19501
19502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19503   std::string *arg1 = 0 ;
19504   std::string *arg2 = 0 ;
19505   int arg3 ;
19506   Dali::Property::Type arg4 ;
19507   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
19508   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
19509
19510   if (!jarg1) {
19511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19512     return ;
19513   }
19514   std::string arg1_str(jarg1);
19515   arg1 = &arg1_str;
19516   if (!jarg2) {
19517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19518     return ;
19519   }
19520   std::string arg2_str(jarg2);
19521   arg2 = &arg2_str;
19522   arg3 = (int)jarg3;
19523   arg4 = (Dali::Property::Type)jarg4;
19524   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
19525   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
19526   {
19527     try {
19528       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19529     } catch (std::out_of_range& e) {
19530       {
19531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19532       };
19533     } catch (std::exception& e) {
19534       {
19535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19536       };
19537     } catch (...) {
19538       {
19539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19540       };
19541     }
19542   }
19543
19544   //argout typemap for const std::string&
19545
19546
19547   //argout typemap for const std::string&
19548
19549 }
19550
19551
19552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
19553   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
19554
19555   arg1 = (Dali::TypeRegistration *)jarg1;
19556   {
19557     try {
19558       delete arg1;
19559     } catch (std::out_of_range& e) {
19560       {
19561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19562       };
19563     } catch (std::exception& e) {
19564       {
19565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19566       };
19567     } catch (...) {
19568       {
19569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19570       };
19571     }
19572   }
19573 }
19574
19575
19576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
19577   void * jresult ;
19578   Dali::TypeRegistration *arg1 = 0 ;
19579   std::string *arg2 = 0 ;
19580   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
19581   Dali::SignalConnectorType *result = 0 ;
19582
19583   arg1 = (Dali::TypeRegistration *)jarg1;
19584   if (!arg1) {
19585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19586     return 0;
19587   }
19588   if (!jarg2) {
19589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19590     return 0;
19591   }
19592   std::string arg2_str(jarg2);
19593   arg2 = &arg2_str;
19594   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
19595   {
19596     try {
19597       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
19598     } catch (std::out_of_range& e) {
19599       {
19600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19601       };
19602     } catch (std::exception& e) {
19603       {
19604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19605       };
19606     } catch (...) {
19607       {
19608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19609       };
19610     }
19611   }
19612   jresult = (void *)result;
19613
19614   //argout typemap for const std::string&
19615
19616   return jresult;
19617 }
19618
19619
19620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
19621   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
19622
19623   arg1 = (Dali::SignalConnectorType *)jarg1;
19624   {
19625     try {
19626       delete arg1;
19627     } catch (std::out_of_range& e) {
19628       {
19629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19630       };
19631     } catch (std::exception& e) {
19632       {
19633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19634       };
19635     } catch (...) {
19636       {
19637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19638       };
19639     }
19640   }
19641 }
19642
19643
19644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
19645   void * jresult ;
19646   Dali::TypeRegistration *arg1 = 0 ;
19647   std::string *arg2 = 0 ;
19648   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
19649   Dali::TypeAction *result = 0 ;
19650
19651   arg1 = (Dali::TypeRegistration *)jarg1;
19652   if (!arg1) {
19653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19654     return 0;
19655   }
19656   if (!jarg2) {
19657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19658     return 0;
19659   }
19660   std::string arg2_str(jarg2);
19661   arg2 = &arg2_str;
19662   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
19663   {
19664     try {
19665       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
19666     } catch (std::out_of_range& e) {
19667       {
19668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19669       };
19670     } catch (std::exception& e) {
19671       {
19672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19673       };
19674     } catch (...) {
19675       {
19676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19677       };
19678     }
19679   }
19680   jresult = (void *)result;
19681
19682   //argout typemap for const std::string&
19683
19684   return jresult;
19685 }
19686
19687
19688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
19689   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
19690
19691   arg1 = (Dali::TypeAction *)jarg1;
19692   {
19693     try {
19694       delete arg1;
19695     } catch (std::out_of_range& e) {
19696       {
19697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19698       };
19699     } catch (std::exception& e) {
19700       {
19701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19702       };
19703     } catch (...) {
19704       {
19705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19706       };
19707     }
19708   }
19709 }
19710
19711
19712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
19713   void * jresult ;
19714   Dali::TypeRegistration *arg1 = 0 ;
19715   std::string *arg2 = 0 ;
19716   Dali::Property::Index arg3 ;
19717   Dali::Property::Type arg4 ;
19718   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
19719   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
19720   Dali::PropertyRegistration *result = 0 ;
19721
19722   arg1 = (Dali::TypeRegistration *)jarg1;
19723   if (!arg1) {
19724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19725     return 0;
19726   }
19727   if (!jarg2) {
19728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19729     return 0;
19730   }
19731   std::string arg2_str(jarg2);
19732   arg2 = &arg2_str;
19733   arg3 = (Dali::Property::Index)jarg3;
19734   arg4 = (Dali::Property::Type)jarg4;
19735   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
19736   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
19737   {
19738     try {
19739       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
19740     } catch (std::out_of_range& e) {
19741       {
19742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19743       };
19744     } catch (std::exception& e) {
19745       {
19746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19747       };
19748     } catch (...) {
19749       {
19750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19751       };
19752     }
19753   }
19754   jresult = (void *)result;
19755
19756   //argout typemap for const std::string&
19757
19758   return jresult;
19759 }
19760
19761
19762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
19763   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
19764
19765   arg1 = (Dali::PropertyRegistration *)jarg1;
19766   {
19767     try {
19768       delete arg1;
19769     } catch (std::out_of_range& e) {
19770       {
19771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19772       };
19773     } catch (std::exception& e) {
19774       {
19775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19776       };
19777     } catch (...) {
19778       {
19779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19780       };
19781     }
19782   }
19783 }
19784
19785
19786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19787   void * jresult ;
19788   Dali::TypeRegistration *arg1 = 0 ;
19789   std::string *arg2 = 0 ;
19790   Dali::Property::Index arg3 ;
19791   Dali::Property::Type arg4 ;
19792   Dali::AnimatablePropertyRegistration *result = 0 ;
19793
19794   arg1 = (Dali::TypeRegistration *)jarg1;
19795   if (!arg1) {
19796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19797     return 0;
19798   }
19799   if (!jarg2) {
19800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19801     return 0;
19802   }
19803   std::string arg2_str(jarg2);
19804   arg2 = &arg2_str;
19805   arg3 = (Dali::Property::Index)jarg3;
19806   arg4 = (Dali::Property::Type)jarg4;
19807   {
19808     try {
19809       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
19810     } catch (std::out_of_range& e) {
19811       {
19812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19813       };
19814     } catch (std::exception& e) {
19815       {
19816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19817       };
19818     } catch (...) {
19819       {
19820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19821       };
19822     }
19823   }
19824   jresult = (void *)result;
19825
19826   //argout typemap for const std::string&
19827
19828   return jresult;
19829 }
19830
19831
19832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
19833   void * jresult ;
19834   Dali::TypeRegistration *arg1 = 0 ;
19835   std::string *arg2 = 0 ;
19836   Dali::Property::Index arg3 ;
19837   Dali::Property::Value *arg4 = 0 ;
19838   Dali::AnimatablePropertyRegistration *result = 0 ;
19839
19840   arg1 = (Dali::TypeRegistration *)jarg1;
19841   if (!arg1) {
19842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19843     return 0;
19844   }
19845   if (!jarg2) {
19846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19847     return 0;
19848   }
19849   std::string arg2_str(jarg2);
19850   arg2 = &arg2_str;
19851   arg3 = (Dali::Property::Index)jarg3;
19852   arg4 = (Dali::Property::Value *)jarg4;
19853   if (!arg4) {
19854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
19855     return 0;
19856   }
19857   {
19858     try {
19859       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
19860     } catch (std::out_of_range& e) {
19861       {
19862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19863       };
19864     } catch (std::exception& e) {
19865       {
19866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19867       };
19868     } catch (...) {
19869       {
19870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19871       };
19872     }
19873   }
19874   jresult = (void *)result;
19875
19876   //argout typemap for const std::string&
19877
19878   return jresult;
19879 }
19880
19881
19882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
19883   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
19884
19885   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
19886   {
19887     try {
19888       delete arg1;
19889     } catch (std::out_of_range& e) {
19890       {
19891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19892       };
19893     } catch (std::exception& e) {
19894       {
19895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19896       };
19897     } catch (...) {
19898       {
19899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19900       };
19901     }
19902   }
19903 }
19904
19905
19906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
19907   void * jresult ;
19908   Dali::TypeRegistration *arg1 = 0 ;
19909   std::string *arg2 = 0 ;
19910   Dali::Property::Index arg3 ;
19911   Dali::Property::Index arg4 ;
19912   unsigned int arg5 ;
19913   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
19914
19915   arg1 = (Dali::TypeRegistration *)jarg1;
19916   if (!arg1) {
19917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19918     return 0;
19919   }
19920   if (!jarg2) {
19921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19922     return 0;
19923   }
19924   std::string arg2_str(jarg2);
19925   arg2 = &arg2_str;
19926   arg3 = (Dali::Property::Index)jarg3;
19927   arg4 = (Dali::Property::Index)jarg4;
19928   arg5 = (unsigned int)jarg5;
19929   {
19930     try {
19931       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
19932     } catch (std::out_of_range& e) {
19933       {
19934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19935       };
19936     } catch (std::exception& e) {
19937       {
19938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19939       };
19940     } catch (...) {
19941       {
19942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19943       };
19944     }
19945   }
19946   jresult = (void *)result;
19947
19948   //argout typemap for const std::string&
19949
19950   return jresult;
19951 }
19952
19953
19954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
19955   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
19956
19957   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
19958   {
19959     try {
19960       delete arg1;
19961     } catch (std::out_of_range& e) {
19962       {
19963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19964       };
19965     } catch (std::exception& e) {
19966       {
19967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19968       };
19969     } catch (...) {
19970       {
19971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19972       };
19973     }
19974   }
19975 }
19976
19977
19978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
19979   void * jresult ;
19980   Dali::TypeRegistration *arg1 = 0 ;
19981   std::string *arg2 = 0 ;
19982   Dali::Property::Index arg3 ;
19983   Dali::Property::Type arg4 ;
19984   Dali::ChildPropertyRegistration *result = 0 ;
19985
19986   arg1 = (Dali::TypeRegistration *)jarg1;
19987   if (!arg1) {
19988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
19989     return 0;
19990   }
19991   if (!jarg2) {
19992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
19993     return 0;
19994   }
19995   std::string arg2_str(jarg2);
19996   arg2 = &arg2_str;
19997   arg3 = (Dali::Property::Index)jarg3;
19998   arg4 = (Dali::Property::Type)jarg4;
19999   {
20000     try {
20001       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
20002     } catch (std::out_of_range& e) {
20003       {
20004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20005       };
20006     } catch (std::exception& e) {
20007       {
20008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20009       };
20010     } catch (...) {
20011       {
20012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20013       };
20014     }
20015   }
20016   jresult = (void *)result;
20017
20018   //argout typemap for const std::string&
20019
20020   return jresult;
20021 }
20022
20023
20024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
20025   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
20026
20027   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
20028   {
20029     try {
20030       delete arg1;
20031     } catch (std::out_of_range& e) {
20032       {
20033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20034       };
20035     } catch (std::exception& e) {
20036       {
20037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20038       };
20039     } catch (...) {
20040       {
20041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20042       };
20043     }
20044   }
20045 }
20046
20047
20048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
20049   unsigned int jresult ;
20050   std::string *arg1 = 0 ;
20051   std::type_info *arg2 = 0 ;
20052   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
20053   bool result;
20054
20055   if (!jarg1) {
20056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20057     return 0;
20058   }
20059   std::string arg1_str(jarg1);
20060   arg1 = &arg1_str;
20061   arg2 = (std::type_info *)jarg2;
20062   if (!arg2) {
20063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
20064     return 0;
20065   }
20066   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
20067   {
20068     try {
20069       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
20070     } catch (std::out_of_range& e) {
20071       {
20072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20073       };
20074     } catch (std::exception& e) {
20075       {
20076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20077       };
20078     } catch (...) {
20079       {
20080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20081       };
20082     }
20083   }
20084   jresult = result;
20085
20086   //argout typemap for const std::string&
20087
20088   return jresult;
20089 }
20090
20091
20092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
20093   unsigned int jresult ;
20094   std::string *arg1 = 0 ;
20095   std::string *arg2 = 0 ;
20096   Dali::Property::Index arg3 ;
20097   Dali::Property::Type arg4 ;
20098   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
20099   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
20100   bool result;
20101
20102   if (!jarg1) {
20103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20104     return 0;
20105   }
20106   std::string arg1_str(jarg1);
20107   arg1 = &arg1_str;
20108   if (!jarg2) {
20109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20110     return 0;
20111   }
20112   std::string arg2_str(jarg2);
20113   arg2 = &arg2_str;
20114   arg3 = (Dali::Property::Index)jarg3;
20115   arg4 = (Dali::Property::Type)jarg4;
20116   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
20117   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
20118   {
20119     try {
20120       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
20121     } catch (std::out_of_range& e) {
20122       {
20123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20124       };
20125     } catch (std::exception& e) {
20126       {
20127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20128       };
20129     } catch (...) {
20130       {
20131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20132       };
20133     }
20134   }
20135   jresult = result;
20136
20137   //argout typemap for const std::string&
20138
20139
20140   //argout typemap for const std::string&
20141
20142   return jresult;
20143 }
20144
20145
20146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
20147   float jresult ;
20148   float result;
20149
20150   result = (float)(float)Dali::ParentOrigin::TOP;
20151   jresult = result;
20152   return jresult;
20153 }
20154
20155
20156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
20157   float jresult ;
20158   float result;
20159
20160   result = (float)(float)Dali::ParentOrigin::BOTTOM;
20161   jresult = result;
20162   return jresult;
20163 }
20164
20165
20166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
20167   float jresult ;
20168   float result;
20169
20170   result = (float)(float)Dali::ParentOrigin::LEFT;
20171   jresult = result;
20172   return jresult;
20173 }
20174
20175
20176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
20177   float jresult ;
20178   float result;
20179
20180   result = (float)(float)Dali::ParentOrigin::RIGHT;
20181   jresult = result;
20182   return jresult;
20183 }
20184
20185
20186 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
20187   float jresult ;
20188   float result;
20189
20190   result = (float)(float)Dali::ParentOrigin::MIDDLE;
20191   jresult = result;
20192   return jresult;
20193 }
20194
20195
20196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
20197   void * jresult ;
20198   Dali::Vector3 *result = 0 ;
20199
20200   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
20201   jresult = (void *)result;
20202   return jresult;
20203 }
20204
20205
20206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
20207   void * jresult ;
20208   Dali::Vector3 *result = 0 ;
20209
20210   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
20211   jresult = (void *)result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
20217   void * jresult ;
20218   Dali::Vector3 *result = 0 ;
20219
20220   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
20221   jresult = (void *)result;
20222   return jresult;
20223 }
20224
20225
20226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
20227   void * jresult ;
20228   Dali::Vector3 *result = 0 ;
20229
20230   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
20231   jresult = (void *)result;
20232   return jresult;
20233 }
20234
20235
20236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
20237   void * jresult ;
20238   Dali::Vector3 *result = 0 ;
20239
20240   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
20241   jresult = (void *)result;
20242   return jresult;
20243 }
20244
20245
20246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
20247   void * jresult ;
20248   Dali::Vector3 *result = 0 ;
20249
20250   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
20251   jresult = (void *)result;
20252   return jresult;
20253 }
20254
20255
20256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
20257   void * jresult ;
20258   Dali::Vector3 *result = 0 ;
20259
20260   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
20261   jresult = (void *)result;
20262   return jresult;
20263 }
20264
20265
20266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
20267   void * jresult ;
20268   Dali::Vector3 *result = 0 ;
20269
20270   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
20271   jresult = (void *)result;
20272   return jresult;
20273 }
20274
20275
20276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
20277   void * jresult ;
20278   Dali::Vector3 *result = 0 ;
20279
20280   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
20281   jresult = (void *)result;
20282   return jresult;
20283 }
20284
20285
20286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
20287   float jresult ;
20288   float result;
20289
20290   result = (float)(float)Dali::AnchorPoint::TOP;
20291   jresult = result;
20292   return jresult;
20293 }
20294
20295
20296 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
20297   float jresult ;
20298   float result;
20299
20300   result = (float)(float)Dali::AnchorPoint::BOTTOM;
20301   jresult = result;
20302   return jresult;
20303 }
20304
20305
20306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
20307   float jresult ;
20308   float result;
20309
20310   result = (float)(float)Dali::AnchorPoint::LEFT;
20311   jresult = result;
20312   return jresult;
20313 }
20314
20315
20316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
20317   float jresult ;
20318   float result;
20319
20320   result = (float)(float)Dali::AnchorPoint::RIGHT;
20321   jresult = result;
20322   return jresult;
20323 }
20324
20325
20326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
20327   float jresult ;
20328   float result;
20329
20330   result = (float)(float)Dali::AnchorPoint::MIDDLE;
20331   jresult = result;
20332   return jresult;
20333 }
20334
20335
20336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
20337   void * jresult ;
20338   Dali::Vector3 *result = 0 ;
20339
20340   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
20341   jresult = (void *)result;
20342   return jresult;
20343 }
20344
20345
20346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
20347   void * jresult ;
20348   Dali::Vector3 *result = 0 ;
20349
20350   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
20351   jresult = (void *)result;
20352   return jresult;
20353 }
20354
20355
20356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
20357   void * jresult ;
20358   Dali::Vector3 *result = 0 ;
20359
20360   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
20361   jresult = (void *)result;
20362   return jresult;
20363 }
20364
20365
20366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
20367   void * jresult ;
20368   Dali::Vector3 *result = 0 ;
20369
20370   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
20371   jresult = (void *)result;
20372   return jresult;
20373 }
20374
20375
20376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
20377   void * jresult ;
20378   Dali::Vector3 *result = 0 ;
20379
20380   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
20381   jresult = (void *)result;
20382   return jresult;
20383 }
20384
20385
20386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
20387   void * jresult ;
20388   Dali::Vector3 *result = 0 ;
20389
20390   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
20391   jresult = (void *)result;
20392   return jresult;
20393 }
20394
20395
20396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
20397   void * jresult ;
20398   Dali::Vector3 *result = 0 ;
20399
20400   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
20401   jresult = (void *)result;
20402   return jresult;
20403 }
20404
20405
20406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
20407   void * jresult ;
20408   Dali::Vector3 *result = 0 ;
20409
20410   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
20411   jresult = (void *)result;
20412   return jresult;
20413 }
20414
20415
20416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
20417   void * jresult ;
20418   Dali::Vector3 *result = 0 ;
20419
20420   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
20421   jresult = (void *)result;
20422   return jresult;
20423 }
20424
20425
20426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
20427   void * jresult ;
20428   Dali::Vector4 *result = 0 ;
20429
20430   result = (Dali::Vector4 *)&Dali::Color::BLACK;
20431   jresult = (void *)result;
20432   return jresult;
20433 }
20434
20435
20436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
20437   void * jresult ;
20438   Dali::Vector4 *result = 0 ;
20439
20440   result = (Dali::Vector4 *)&Dali::Color::WHITE;
20441   jresult = (void *)result;
20442   return jresult;
20443 }
20444
20445
20446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
20447   void * jresult ;
20448   Dali::Vector4 *result = 0 ;
20449
20450   result = (Dali::Vector4 *)&Dali::Color::RED;
20451   jresult = (void *)result;
20452   return jresult;
20453 }
20454
20455
20456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
20457   void * jresult ;
20458   Dali::Vector4 *result = 0 ;
20459
20460   result = (Dali::Vector4 *)&Dali::Color::GREEN;
20461   jresult = (void *)result;
20462   return jresult;
20463 }
20464
20465
20466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
20467   void * jresult ;
20468   Dali::Vector4 *result = 0 ;
20469
20470   result = (Dali::Vector4 *)&Dali::Color::BLUE;
20471   jresult = (void *)result;
20472   return jresult;
20473 }
20474
20475
20476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
20477   void * jresult ;
20478   Dali::Vector4 *result = 0 ;
20479
20480   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
20481   jresult = (void *)result;
20482   return jresult;
20483 }
20484
20485
20486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
20487   void * jresult ;
20488   Dali::Vector4 *result = 0 ;
20489
20490   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
20491   jresult = (void *)result;
20492   return jresult;
20493 }
20494
20495
20496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
20497   void * jresult ;
20498   Dali::Vector4 *result = 0 ;
20499
20500   result = (Dali::Vector4 *)&Dali::Color::CYAN;
20501   jresult = (void *)result;
20502   return jresult;
20503 }
20504
20505
20506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
20507   void * jresult ;
20508   Dali::Vector4 *result = 0 ;
20509
20510   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
20511   jresult = (void *)result;
20512   return jresult;
20513 }
20514
20515
20516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
20517   float jresult ;
20518   float result;
20519
20520   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
20521   jresult = result;
20522   return jresult;
20523 }
20524
20525
20526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
20527   float jresult ;
20528   float result;
20529
20530   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
20531   jresult = result;
20532   return jresult;
20533 }
20534
20535
20536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
20537   float jresult ;
20538   float result;
20539
20540   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
20541   jresult = result;
20542   return jresult;
20543 }
20544
20545
20546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
20547   float jresult ;
20548   float result;
20549
20550   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
20551   jresult = result;
20552   return jresult;
20553 }
20554
20555
20556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
20557   float jresult ;
20558   float result;
20559
20560   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
20561   jresult = result;
20562   return jresult;
20563 }
20564
20565
20566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
20567   float jresult ;
20568   float result;
20569
20570   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
20571   jresult = result;
20572   return jresult;
20573 }
20574
20575
20576 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
20577   float jresult ;
20578   float result;
20579
20580   result = (float)(float)Dali::Math::PI;
20581   jresult = result;
20582   return jresult;
20583 }
20584
20585
20586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
20587   float jresult ;
20588   float result;
20589
20590   result = (float)(float)Dali::Math::PI_2;
20591   jresult = result;
20592   return jresult;
20593 }
20594
20595
20596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
20597   float jresult ;
20598   float result;
20599
20600   result = (float)(float)Dali::Math::PI_4;
20601   jresult = result;
20602   return jresult;
20603 }
20604
20605
20606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
20607   float jresult ;
20608   float result;
20609
20610   result = (float)(float)Dali::Math::PI_OVER_180;
20611   jresult = result;
20612   return jresult;
20613 }
20614
20615
20616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
20617   float jresult ;
20618   float result;
20619
20620   result = (float)(float)Dali::Math::ONE80_OVER_PI;
20621   jresult = result;
20622   return jresult;
20623 }
20624
20625
20626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
20627   int jresult ;
20628   Dali::ResizePolicy::Type result;
20629
20630   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
20631   jresult = (int)result;
20632   return jresult;
20633 }
20634
20635
20636 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
20637   unsigned long jresult ;
20638   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20639   Dali::VectorBase::SizeType result;
20640
20641   arg1 = (Dali::VectorBase *)jarg1;
20642   {
20643     try {
20644       result = ((Dali::VectorBase const *)arg1)->Count();
20645     } catch (std::out_of_range& e) {
20646       {
20647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20648       };
20649     } catch (std::exception& e) {
20650       {
20651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20652       };
20653     } catch (...) {
20654       {
20655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20656       };
20657     }
20658   }
20659   jresult = (unsigned long)result;
20660   return jresult;
20661 }
20662
20663
20664 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
20665   unsigned long jresult ;
20666   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20667   Dali::VectorBase::SizeType result;
20668
20669   arg1 = (Dali::VectorBase *)jarg1;
20670   {
20671     try {
20672       result = ((Dali::VectorBase const *)arg1)->Size();
20673     } catch (std::out_of_range& e) {
20674       {
20675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20676       };
20677     } catch (std::exception& e) {
20678       {
20679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20680       };
20681     } catch (...) {
20682       {
20683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20684       };
20685     }
20686   }
20687   jresult = (unsigned long)result;
20688   return jresult;
20689 }
20690
20691
20692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
20693   unsigned int jresult ;
20694   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20695   bool result;
20696
20697   arg1 = (Dali::VectorBase *)jarg1;
20698   {
20699     try {
20700       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
20701     } catch (std::out_of_range& e) {
20702       {
20703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20704       };
20705     } catch (std::exception& e) {
20706       {
20707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20708       };
20709     } catch (...) {
20710       {
20711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20712       };
20713     }
20714   }
20715   jresult = result;
20716   return jresult;
20717 }
20718
20719
20720 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
20721   unsigned long jresult ;
20722   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20723   Dali::VectorBase::SizeType result;
20724
20725   arg1 = (Dali::VectorBase *)jarg1;
20726   {
20727     try {
20728       result = ((Dali::VectorBase const *)arg1)->Capacity();
20729     } catch (std::out_of_range& e) {
20730       {
20731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20732       };
20733     } catch (std::exception& e) {
20734       {
20735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20736       };
20737     } catch (...) {
20738       {
20739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20740       };
20741     }
20742   }
20743   jresult = (unsigned long)result;
20744   return jresult;
20745 }
20746
20747
20748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
20749   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
20750
20751   arg1 = (Dali::VectorBase *)jarg1;
20752   {
20753     try {
20754       (arg1)->Release();
20755     } catch (std::out_of_range& e) {
20756       {
20757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20758       };
20759     } catch (std::exception& e) {
20760       {
20761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20762       };
20763     } catch (...) {
20764       {
20765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20766       };
20767     }
20768   }
20769 }
20770
20771
20772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
20773   void * jresult ;
20774   Dali::Image *result = 0 ;
20775
20776   {
20777     try {
20778       result = (Dali::Image *)new Dali::Image();
20779     } catch (std::out_of_range& e) {
20780       {
20781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20782       };
20783     } catch (std::exception& e) {
20784       {
20785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20786       };
20787     } catch (...) {
20788       {
20789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20790       };
20791     }
20792   }
20793   jresult = (void *)result;
20794   return jresult;
20795 }
20796
20797
20798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
20799   Dali::Image *arg1 = (Dali::Image *) 0 ;
20800
20801   arg1 = (Dali::Image *)jarg1;
20802   {
20803     try {
20804       delete arg1;
20805     } catch (std::out_of_range& e) {
20806       {
20807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20808       };
20809     } catch (std::exception& e) {
20810       {
20811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20812       };
20813     } catch (...) {
20814       {
20815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20816       };
20817     }
20818   }
20819 }
20820
20821
20822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
20823   void * jresult ;
20824   Dali::Image *arg1 = 0 ;
20825   Dali::Image *result = 0 ;
20826
20827   arg1 = (Dali::Image *)jarg1;
20828   if (!arg1) {
20829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20830     return 0;
20831   }
20832   {
20833     try {
20834       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
20835     } catch (std::out_of_range& e) {
20836       {
20837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20838       };
20839     } catch (std::exception& e) {
20840       {
20841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20842       };
20843     } catch (...) {
20844       {
20845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20846       };
20847     }
20848   }
20849   jresult = (void *)result;
20850   return jresult;
20851 }
20852
20853
20854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
20855   void * jresult ;
20856   Dali::Image *arg1 = (Dali::Image *) 0 ;
20857   Dali::Image *arg2 = 0 ;
20858   Dali::Image *result = 0 ;
20859
20860   arg1 = (Dali::Image *)jarg1;
20861   arg2 = (Dali::Image *)jarg2;
20862   if (!arg2) {
20863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
20864     return 0;
20865   }
20866   {
20867     try {
20868       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
20869     } catch (std::out_of_range& e) {
20870       {
20871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20872       };
20873     } catch (std::exception& e) {
20874       {
20875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20876       };
20877     } catch (...) {
20878       {
20879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20880       };
20881     }
20882   }
20883   jresult = (void *)result;
20884   return jresult;
20885 }
20886
20887
20888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
20889   void * jresult ;
20890   Dali::BaseHandle arg1 ;
20891   Dali::BaseHandle *argp1 ;
20892   Dali::Image result;
20893
20894   argp1 = (Dali::BaseHandle *)jarg1;
20895   if (!argp1) {
20896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20897     return 0;
20898   }
20899   arg1 = *argp1;
20900   {
20901     try {
20902       result = Dali::Image::DownCast(arg1);
20903     } catch (std::out_of_range& e) {
20904       {
20905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20906       };
20907     } catch (std::exception& e) {
20908       {
20909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20910       };
20911     } catch (...) {
20912       {
20913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20914       };
20915     }
20916   }
20917   jresult = new Dali::Image((const Dali::Image &)result);
20918   return jresult;
20919 }
20920
20921
20922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
20923   unsigned int jresult ;
20924   Dali::Image *arg1 = (Dali::Image *) 0 ;
20925   unsigned int result;
20926
20927   arg1 = (Dali::Image *)jarg1;
20928   {
20929     try {
20930       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
20931     } catch (std::out_of_range& e) {
20932       {
20933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20934       };
20935     } catch (std::exception& e) {
20936       {
20937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20938       };
20939     } catch (...) {
20940       {
20941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20942       };
20943     }
20944   }
20945   jresult = result;
20946   return jresult;
20947 }
20948
20949
20950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
20951   unsigned int jresult ;
20952   Dali::Image *arg1 = (Dali::Image *) 0 ;
20953   unsigned int result;
20954
20955   arg1 = (Dali::Image *)jarg1;
20956   {
20957     try {
20958       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
20959     } catch (std::out_of_range& e) {
20960       {
20961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20962       };
20963     } catch (std::exception& e) {
20964       {
20965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20966       };
20967     } catch (...) {
20968       {
20969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20970       };
20971     }
20972   }
20973   jresult = result;
20974   return jresult;
20975 }
20976
20977
20978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
20979   void * jresult ;
20980   Dali::Image *arg1 = (Dali::Image *) 0 ;
20981   Dali::Image::ImageSignalType *result = 0 ;
20982
20983   arg1 = (Dali::Image *)jarg1;
20984   {
20985     try {
20986       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
20987     } catch (std::out_of_range& e) {
20988       {
20989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20990       };
20991     } catch (std::exception& e) {
20992       {
20993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20994       };
20995     } catch (...) {
20996       {
20997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20998       };
20999     }
21000   }
21001   jresult = (void *)result;
21002   return jresult;
21003 }
21004
21005
21006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
21007   int jresult ;
21008   Dali::Pixel::Format result;
21009
21010   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
21011   jresult = (int)result;
21012   return jresult;
21013 }
21014
21015
21016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
21017   int jresult ;
21018   Dali::Pixel::Format result;
21019
21020   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
21021   jresult = (int)result;
21022   return jresult;
21023 }
21024
21025
21026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
21027   unsigned int jresult ;
21028   Dali::Pixel::Format arg1 ;
21029   bool result;
21030
21031   arg1 = (Dali::Pixel::Format)jarg1;
21032   {
21033     try {
21034       result = (bool)Dali::Pixel::HasAlpha(arg1);
21035     } catch (std::out_of_range& e) {
21036       {
21037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21038       };
21039     } catch (std::exception& e) {
21040       {
21041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21042       };
21043     } catch (...) {
21044       {
21045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21046       };
21047     }
21048   }
21049   jresult = result;
21050   return jresult;
21051 }
21052
21053
21054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
21055   unsigned int jresult ;
21056   Dali::Pixel::Format arg1 ;
21057   unsigned int result;
21058
21059   arg1 = (Dali::Pixel::Format)jarg1;
21060   {
21061     try {
21062       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
21063     } catch (std::out_of_range& e) {
21064       {
21065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21066       };
21067     } catch (std::exception& e) {
21068       {
21069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21070       };
21071     } catch (...) {
21072       {
21073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21074       };
21075     }
21076   }
21077   jresult = result;
21078   return jresult;
21079 }
21080
21081
21082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
21083   Dali::Pixel::Format arg1 ;
21084   int *arg2 = 0 ;
21085   int *arg3 = 0 ;
21086
21087   arg1 = (Dali::Pixel::Format)jarg1;
21088   arg2 = (int *)jarg2;
21089   if (!arg2) {
21090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21091     return ;
21092   }
21093   arg3 = (int *)jarg3;
21094   if (!arg3) {
21095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
21096     return ;
21097   }
21098   {
21099     try {
21100       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
21101     } catch (std::out_of_range& e) {
21102       {
21103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21104       };
21105     } catch (std::exception& e) {
21106       {
21107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21108       };
21109     } catch (...) {
21110       {
21111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21112       };
21113     }
21114   }
21115 }
21116
21117
21118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
21119   void * jresult ;
21120   unsigned char *arg1 = (unsigned char *) 0 ;
21121   unsigned int arg2 ;
21122   unsigned int arg3 ;
21123   unsigned int arg4 ;
21124   Dali::Pixel::Format arg5 ;
21125   Dali::PixelData::ReleaseFunction arg6 ;
21126   Dali::PixelData result;
21127
21128   arg1 = jarg1;
21129   arg2 = (unsigned int)jarg2;
21130   arg3 = (unsigned int)jarg3;
21131   arg4 = (unsigned int)jarg4;
21132   arg5 = (Dali::Pixel::Format)jarg5;
21133   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
21134   {
21135     try {
21136       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
21137     } catch (std::out_of_range& e) {
21138       {
21139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21140       };
21141     } catch (std::exception& e) {
21142       {
21143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21144       };
21145     } catch (...) {
21146       {
21147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21148       };
21149     }
21150   }
21151   jresult = new Dali::PixelData((const Dali::PixelData &)result);
21152
21153
21154   return jresult;
21155 }
21156
21157
21158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
21159   void * jresult ;
21160   Dali::PixelData *result = 0 ;
21161
21162   {
21163     try {
21164       result = (Dali::PixelData *)new Dali::PixelData();
21165     } catch (std::out_of_range& e) {
21166       {
21167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21168       };
21169     } catch (std::exception& e) {
21170       {
21171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21172       };
21173     } catch (...) {
21174       {
21175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21176       };
21177     }
21178   }
21179   jresult = (void *)result;
21180   return jresult;
21181 }
21182
21183
21184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
21185   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21186
21187   arg1 = (Dali::PixelData *)jarg1;
21188   {
21189     try {
21190       delete arg1;
21191     } catch (std::out_of_range& e) {
21192       {
21193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21194       };
21195     } catch (std::exception& e) {
21196       {
21197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21198       };
21199     } catch (...) {
21200       {
21201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21202       };
21203     }
21204   }
21205 }
21206
21207
21208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
21209   void * jresult ;
21210   Dali::PixelData *arg1 = 0 ;
21211   Dali::PixelData *result = 0 ;
21212
21213   arg1 = (Dali::PixelData *)jarg1;
21214   if (!arg1) {
21215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21216     return 0;
21217   }
21218   {
21219     try {
21220       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
21221     } catch (std::out_of_range& e) {
21222       {
21223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21224       };
21225     } catch (std::exception& e) {
21226       {
21227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21228       };
21229     } catch (...) {
21230       {
21231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21232       };
21233     }
21234   }
21235   jresult = (void *)result;
21236   return jresult;
21237 }
21238
21239
21240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
21241   void * jresult ;
21242   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21243   Dali::PixelData *arg2 = 0 ;
21244   Dali::PixelData *result = 0 ;
21245
21246   arg1 = (Dali::PixelData *)jarg1;
21247   arg2 = (Dali::PixelData *)jarg2;
21248   if (!arg2) {
21249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
21250     return 0;
21251   }
21252   {
21253     try {
21254       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
21255     } catch (std::out_of_range& e) {
21256       {
21257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21258       };
21259     } catch (std::exception& e) {
21260       {
21261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21262       };
21263     } catch (...) {
21264       {
21265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21266       };
21267     }
21268   }
21269   jresult = (void *)result;
21270   return jresult;
21271 }
21272
21273
21274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
21275   unsigned int jresult ;
21276   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21277   unsigned int result;
21278
21279   arg1 = (Dali::PixelData *)jarg1;
21280   {
21281     try {
21282       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
21283     } catch (std::out_of_range& e) {
21284       {
21285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21286       };
21287     } catch (std::exception& e) {
21288       {
21289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21290       };
21291     } catch (...) {
21292       {
21293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21294       };
21295     }
21296   }
21297   jresult = result;
21298   return jresult;
21299 }
21300
21301
21302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
21303   unsigned int jresult ;
21304   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21305   unsigned int result;
21306
21307   arg1 = (Dali::PixelData *)jarg1;
21308   {
21309     try {
21310       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
21311     } catch (std::out_of_range& e) {
21312       {
21313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21314       };
21315     } catch (std::exception& e) {
21316       {
21317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21318       };
21319     } catch (...) {
21320       {
21321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21322       };
21323     }
21324   }
21325   jresult = result;
21326   return jresult;
21327 }
21328
21329
21330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
21331   int jresult ;
21332   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
21333   Dali::Pixel::Format result;
21334
21335   arg1 = (Dali::PixelData *)jarg1;
21336   {
21337     try {
21338       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
21339     } catch (std::out_of_range& e) {
21340       {
21341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21342       };
21343     } catch (std::exception& e) {
21344       {
21345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21346       };
21347     } catch (...) {
21348       {
21349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21350       };
21351     }
21352   }
21353   jresult = (int)result;
21354   return jresult;
21355 }
21356
21357
21358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
21359   unsigned int jresult ;
21360   unsigned int result;
21361
21362   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
21363   jresult = result;
21364   return jresult;
21365 }
21366
21367
21368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
21369   unsigned int jresult ;
21370   unsigned int result;
21371
21372   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
21373   jresult = result;
21374   return jresult;
21375 }
21376
21377
21378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
21379   unsigned int jresult ;
21380   unsigned int result;
21381
21382   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
21383   jresult = result;
21384   return jresult;
21385 }
21386
21387
21388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
21389   unsigned int jresult ;
21390   unsigned int result;
21391
21392   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
21393   jresult = result;
21394   return jresult;
21395 }
21396
21397
21398 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
21399   unsigned int jresult ;
21400   unsigned int result;
21401
21402   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
21403   jresult = result;
21404   return jresult;
21405 }
21406
21407
21408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
21409   unsigned int jresult ;
21410   unsigned int result;
21411
21412   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
21413   jresult = result;
21414   return jresult;
21415 }
21416
21417
21418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
21419   void * jresult ;
21420   Dali::TextureType::Type arg1 ;
21421   Dali::Pixel::Format arg2 ;
21422   unsigned int arg3 ;
21423   unsigned int arg4 ;
21424   Dali::Texture result;
21425
21426   arg1 = (Dali::TextureType::Type)jarg1;
21427   arg2 = (Dali::Pixel::Format)jarg2;
21428   arg3 = (unsigned int)jarg3;
21429   arg4 = (unsigned int)jarg4;
21430   {
21431     try {
21432       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
21433     } catch (std::out_of_range& e) {
21434       {
21435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21436       };
21437     } catch (std::exception& e) {
21438       {
21439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21440       };
21441     } catch (...) {
21442       {
21443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21444       };
21445     }
21446   }
21447   jresult = new Dali::Texture((const Dali::Texture &)result);
21448   return jresult;
21449 }
21450
21451
21452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
21453   void * jresult ;
21454   NativeImageInterface *arg1 = 0 ;
21455   Dali::Texture result;
21456
21457   arg1 = (NativeImageInterface *)jarg1;
21458   if (!arg1) {
21459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
21460     return 0;
21461   }
21462   {
21463     try {
21464       result = Dali::Texture::New(*arg1);
21465     } catch (std::out_of_range& e) {
21466       {
21467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21468       };
21469     } catch (std::exception& e) {
21470       {
21471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21472       };
21473     } catch (...) {
21474       {
21475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21476       };
21477     }
21478   }
21479   jresult = new Dali::Texture((const Dali::Texture &)result);
21480   return jresult;
21481 }
21482
21483
21484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
21485   void * jresult ;
21486   Dali::Texture *result = 0 ;
21487
21488   {
21489     try {
21490       result = (Dali::Texture *)new Dali::Texture();
21491     } catch (std::out_of_range& e) {
21492       {
21493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21494       };
21495     } catch (std::exception& e) {
21496       {
21497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21498       };
21499     } catch (...) {
21500       {
21501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21502       };
21503     }
21504   }
21505   jresult = (void *)result;
21506   return jresult;
21507 }
21508
21509
21510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
21511   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21512
21513   arg1 = (Dali::Texture *)jarg1;
21514   {
21515     try {
21516       delete arg1;
21517     } catch (std::out_of_range& e) {
21518       {
21519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21520       };
21521     } catch (std::exception& e) {
21522       {
21523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21524       };
21525     } catch (...) {
21526       {
21527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21528       };
21529     }
21530   }
21531 }
21532
21533
21534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
21535   void * jresult ;
21536   Dali::Texture *arg1 = 0 ;
21537   Dali::Texture *result = 0 ;
21538
21539   arg1 = (Dali::Texture *)jarg1;
21540   if (!arg1) {
21541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21542     return 0;
21543   }
21544   {
21545     try {
21546       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
21547     } catch (std::out_of_range& e) {
21548       {
21549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21550       };
21551     } catch (std::exception& e) {
21552       {
21553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21554       };
21555     } catch (...) {
21556       {
21557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21558       };
21559     }
21560   }
21561   jresult = (void *)result;
21562   return jresult;
21563 }
21564
21565
21566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
21567   void * jresult ;
21568   Dali::BaseHandle arg1 ;
21569   Dali::BaseHandle *argp1 ;
21570   Dali::Texture result;
21571
21572   argp1 = (Dali::BaseHandle *)jarg1;
21573   if (!argp1) {
21574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21575     return 0;
21576   }
21577   arg1 = *argp1;
21578   {
21579     try {
21580       result = Dali::Texture::DownCast(arg1);
21581     } catch (std::out_of_range& e) {
21582       {
21583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21584       };
21585     } catch (std::exception& e) {
21586       {
21587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21588       };
21589     } catch (...) {
21590       {
21591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21592       };
21593     }
21594   }
21595   jresult = new Dali::Texture((const Dali::Texture &)result);
21596   return jresult;
21597 }
21598
21599
21600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
21601   void * jresult ;
21602   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21603   Dali::Texture *arg2 = 0 ;
21604   Dali::Texture *result = 0 ;
21605
21606   arg1 = (Dali::Texture *)jarg1;
21607   arg2 = (Dali::Texture *)jarg2;
21608   if (!arg2) {
21609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
21610     return 0;
21611   }
21612   {
21613     try {
21614       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
21615     } catch (std::out_of_range& e) {
21616       {
21617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21618       };
21619     } catch (std::exception& e) {
21620       {
21621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21622       };
21623     } catch (...) {
21624       {
21625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21626       };
21627     }
21628   }
21629   jresult = (void *)result;
21630   return jresult;
21631 }
21632
21633
21634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
21635   unsigned int jresult ;
21636   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21637   Dali::PixelData arg2 ;
21638   Dali::PixelData *argp2 ;
21639   bool result;
21640
21641   arg1 = (Dali::Texture *)jarg1;
21642   argp2 = (Dali::PixelData *)jarg2;
21643   if (!argp2) {
21644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21645     return 0;
21646   }
21647   arg2 = *argp2;
21648   {
21649     try {
21650       result = (bool)(arg1)->Upload(arg2);
21651     } catch (std::out_of_range& e) {
21652       {
21653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21654       };
21655     } catch (std::exception& e) {
21656       {
21657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21658       };
21659     } catch (...) {
21660       {
21661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21662       };
21663     }
21664   }
21665   jresult = result;
21666   return jresult;
21667 }
21668
21669
21670 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) {
21671   unsigned int jresult ;
21672   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21673   Dali::PixelData arg2 ;
21674   unsigned int arg3 ;
21675   unsigned int arg4 ;
21676   unsigned int arg5 ;
21677   unsigned int arg6 ;
21678   unsigned int arg7 ;
21679   unsigned int arg8 ;
21680   Dali::PixelData *argp2 ;
21681   bool result;
21682
21683   arg1 = (Dali::Texture *)jarg1;
21684   argp2 = (Dali::PixelData *)jarg2;
21685   if (!argp2) {
21686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
21687     return 0;
21688   }
21689   arg2 = *argp2;
21690   arg3 = (unsigned int)jarg3;
21691   arg4 = (unsigned int)jarg4;
21692   arg5 = (unsigned int)jarg5;
21693   arg6 = (unsigned int)jarg6;
21694   arg7 = (unsigned int)jarg7;
21695   arg8 = (unsigned int)jarg8;
21696   {
21697     try {
21698       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
21699     } catch (std::out_of_range& e) {
21700       {
21701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21702       };
21703     } catch (std::exception& e) {
21704       {
21705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21706       };
21707     } catch (...) {
21708       {
21709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21710       };
21711     }
21712   }
21713   jresult = result;
21714   return jresult;
21715 }
21716
21717
21718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
21719   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21720
21721   arg1 = (Dali::Texture *)jarg1;
21722   {
21723     try {
21724       (arg1)->GenerateMipmaps();
21725     } catch (std::out_of_range& e) {
21726       {
21727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21728       };
21729     } catch (std::exception& e) {
21730       {
21731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21732       };
21733     } catch (...) {
21734       {
21735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21736       };
21737     }
21738   }
21739 }
21740
21741
21742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
21743   unsigned int jresult ;
21744   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21745   unsigned int result;
21746
21747   arg1 = (Dali::Texture *)jarg1;
21748   {
21749     try {
21750       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
21751     } catch (std::out_of_range& e) {
21752       {
21753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21754       };
21755     } catch (std::exception& e) {
21756       {
21757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21758       };
21759     } catch (...) {
21760       {
21761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21762       };
21763     }
21764   }
21765   jresult = result;
21766   return jresult;
21767 }
21768
21769
21770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
21771   unsigned int jresult ;
21772   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
21773   unsigned int result;
21774
21775   arg1 = (Dali::Texture *)jarg1;
21776   {
21777     try {
21778       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
21779     } catch (std::out_of_range& e) {
21780       {
21781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21782       };
21783     } catch (std::exception& e) {
21784       {
21785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21786       };
21787     } catch (...) {
21788       {
21789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21790       };
21791     }
21792   }
21793   jresult = result;
21794   return jresult;
21795 }
21796
21797
21798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
21799   void * jresult ;
21800   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
21801   Dali::Texture *result = 0 ;
21802
21803   arg1 = (Dali::Internal::Texture *)jarg1;
21804   {
21805     try {
21806       result = (Dali::Texture *)new Dali::Texture(arg1);
21807     } catch (std::out_of_range& e) {
21808       {
21809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21810       };
21811     } catch (std::exception& e) {
21812       {
21813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21814       };
21815     } catch (...) {
21816       {
21817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21818       };
21819     }
21820   }
21821   jresult = (void *)result;
21822   return jresult;
21823 }
21824
21825
21826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
21827   void * jresult ;
21828   Dali::Sampler result;
21829
21830   {
21831     try {
21832       result = Dali::Sampler::New();
21833     } catch (std::out_of_range& e) {
21834       {
21835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21836       };
21837     } catch (std::exception& e) {
21838       {
21839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21840       };
21841     } catch (...) {
21842       {
21843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21844       };
21845     }
21846   }
21847   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21848   return jresult;
21849 }
21850
21851
21852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
21853   void * jresult ;
21854   Dali::Sampler *result = 0 ;
21855
21856   {
21857     try {
21858       result = (Dali::Sampler *)new Dali::Sampler();
21859     } catch (std::out_of_range& e) {
21860       {
21861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21862       };
21863     } catch (std::exception& e) {
21864       {
21865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21866       };
21867     } catch (...) {
21868       {
21869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21870       };
21871     }
21872   }
21873   jresult = (void *)result;
21874   return jresult;
21875 }
21876
21877
21878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
21879   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21880
21881   arg1 = (Dali::Sampler *)jarg1;
21882   {
21883     try {
21884       delete arg1;
21885     } catch (std::out_of_range& e) {
21886       {
21887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21888       };
21889     } catch (std::exception& e) {
21890       {
21891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21892       };
21893     } catch (...) {
21894       {
21895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21896       };
21897     }
21898   }
21899 }
21900
21901
21902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
21903   void * jresult ;
21904   Dali::Sampler *arg1 = 0 ;
21905   Dali::Sampler *result = 0 ;
21906
21907   arg1 = (Dali::Sampler *)jarg1;
21908   if (!arg1) {
21909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21910     return 0;
21911   }
21912   {
21913     try {
21914       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
21915     } catch (std::out_of_range& e) {
21916       {
21917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21918       };
21919     } catch (std::exception& e) {
21920       {
21921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21922       };
21923     } catch (...) {
21924       {
21925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21926       };
21927     }
21928   }
21929   jresult = (void *)result;
21930   return jresult;
21931 }
21932
21933
21934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
21935   void * jresult ;
21936   Dali::BaseHandle arg1 ;
21937   Dali::BaseHandle *argp1 ;
21938   Dali::Sampler result;
21939
21940   argp1 = (Dali::BaseHandle *)jarg1;
21941   if (!argp1) {
21942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
21943     return 0;
21944   }
21945   arg1 = *argp1;
21946   {
21947     try {
21948       result = Dali::Sampler::DownCast(arg1);
21949     } catch (std::out_of_range& e) {
21950       {
21951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21952       };
21953     } catch (std::exception& e) {
21954       {
21955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21956       };
21957     } catch (...) {
21958       {
21959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21960       };
21961     }
21962   }
21963   jresult = new Dali::Sampler((const Dali::Sampler &)result);
21964   return jresult;
21965 }
21966
21967
21968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
21969   void * jresult ;
21970   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
21971   Dali::Sampler *arg2 = 0 ;
21972   Dali::Sampler *result = 0 ;
21973
21974   arg1 = (Dali::Sampler *)jarg1;
21975   arg2 = (Dali::Sampler *)jarg2;
21976   if (!arg2) {
21977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
21978     return 0;
21979   }
21980   {
21981     try {
21982       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
21983     } catch (std::out_of_range& e) {
21984       {
21985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21986       };
21987     } catch (std::exception& e) {
21988       {
21989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21990       };
21991     } catch (...) {
21992       {
21993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21994       };
21995     }
21996   }
21997   jresult = (void *)result;
21998   return jresult;
21999 }
22000
22001
22002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
22003   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22004   Dali::FilterMode::Type arg2 ;
22005   Dali::FilterMode::Type arg3 ;
22006
22007   arg1 = (Dali::Sampler *)jarg1;
22008   arg2 = (Dali::FilterMode::Type)jarg2;
22009   arg3 = (Dali::FilterMode::Type)jarg3;
22010   {
22011     try {
22012       (arg1)->SetFilterMode(arg2,arg3);
22013     } catch (std::out_of_range& e) {
22014       {
22015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22016       };
22017     } catch (std::exception& e) {
22018       {
22019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22020       };
22021     } catch (...) {
22022       {
22023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22024       };
22025     }
22026   }
22027 }
22028
22029
22030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
22031   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22032   Dali::WrapMode::Type arg2 ;
22033   Dali::WrapMode::Type arg3 ;
22034
22035   arg1 = (Dali::Sampler *)jarg1;
22036   arg2 = (Dali::WrapMode::Type)jarg2;
22037   arg3 = (Dali::WrapMode::Type)jarg3;
22038   {
22039     try {
22040       (arg1)->SetWrapMode(arg2,arg3);
22041     } catch (std::out_of_range& e) {
22042       {
22043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22044       };
22045     } catch (std::exception& e) {
22046       {
22047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22048       };
22049     } catch (...) {
22050       {
22051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22052       };
22053     }
22054   }
22055 }
22056
22057
22058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
22059   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
22060   Dali::WrapMode::Type arg2 ;
22061   Dali::WrapMode::Type arg3 ;
22062   Dali::WrapMode::Type arg4 ;
22063
22064   arg1 = (Dali::Sampler *)jarg1;
22065   arg2 = (Dali::WrapMode::Type)jarg2;
22066   arg3 = (Dali::WrapMode::Type)jarg3;
22067   arg4 = (Dali::WrapMode::Type)jarg4;
22068   {
22069     try {
22070       (arg1)->SetWrapMode(arg2,arg3,arg4);
22071     } catch (std::out_of_range& e) {
22072       {
22073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22074       };
22075     } catch (std::exception& e) {
22076       {
22077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22078       };
22079     } catch (...) {
22080       {
22081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22082       };
22083     }
22084   }
22085 }
22086
22087
22088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
22089   void * jresult ;
22090   Dali::TextureSet result;
22091
22092   {
22093     try {
22094       result = Dali::TextureSet::New();
22095     } catch (std::out_of_range& e) {
22096       {
22097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22098       };
22099     } catch (std::exception& e) {
22100       {
22101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22102       };
22103     } catch (...) {
22104       {
22105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22106       };
22107     }
22108   }
22109   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22110   return jresult;
22111 }
22112
22113
22114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
22115   void * jresult ;
22116   Dali::TextureSet *result = 0 ;
22117
22118   {
22119     try {
22120       result = (Dali::TextureSet *)new Dali::TextureSet();
22121     } catch (std::out_of_range& e) {
22122       {
22123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22124       };
22125     } catch (std::exception& e) {
22126       {
22127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22128       };
22129     } catch (...) {
22130       {
22131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22132       };
22133     }
22134   }
22135   jresult = (void *)result;
22136   return jresult;
22137 }
22138
22139
22140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
22141   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22142
22143   arg1 = (Dali::TextureSet *)jarg1;
22144   {
22145     try {
22146       delete arg1;
22147     } catch (std::out_of_range& e) {
22148       {
22149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22150       };
22151     } catch (std::exception& e) {
22152       {
22153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22154       };
22155     } catch (...) {
22156       {
22157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22158       };
22159     }
22160   }
22161 }
22162
22163
22164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
22165   void * jresult ;
22166   Dali::TextureSet *arg1 = 0 ;
22167   Dali::TextureSet *result = 0 ;
22168
22169   arg1 = (Dali::TextureSet *)jarg1;
22170   if (!arg1) {
22171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22172     return 0;
22173   }
22174   {
22175     try {
22176       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
22177     } catch (std::out_of_range& e) {
22178       {
22179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22180       };
22181     } catch (std::exception& e) {
22182       {
22183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22184       };
22185     } catch (...) {
22186       {
22187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22188       };
22189     }
22190   }
22191   jresult = (void *)result;
22192   return jresult;
22193 }
22194
22195
22196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
22197   void * jresult ;
22198   Dali::BaseHandle arg1 ;
22199   Dali::BaseHandle *argp1 ;
22200   Dali::TextureSet result;
22201
22202   argp1 = (Dali::BaseHandle *)jarg1;
22203   if (!argp1) {
22204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22205     return 0;
22206   }
22207   arg1 = *argp1;
22208   {
22209     try {
22210       result = Dali::TextureSet::DownCast(arg1);
22211     } catch (std::out_of_range& e) {
22212       {
22213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22214       };
22215     } catch (std::exception& e) {
22216       {
22217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22218       };
22219     } catch (...) {
22220       {
22221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22222       };
22223     }
22224   }
22225   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
22226   return jresult;
22227 }
22228
22229
22230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
22231   void * jresult ;
22232   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22233   Dali::TextureSet *arg2 = 0 ;
22234   Dali::TextureSet *result = 0 ;
22235
22236   arg1 = (Dali::TextureSet *)jarg1;
22237   arg2 = (Dali::TextureSet *)jarg2;
22238   if (!arg2) {
22239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
22240     return 0;
22241   }
22242   {
22243     try {
22244       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
22245     } catch (std::out_of_range& e) {
22246       {
22247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22248       };
22249     } catch (std::exception& e) {
22250       {
22251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22252       };
22253     } catch (...) {
22254       {
22255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22256       };
22257     }
22258   }
22259   jresult = (void *)result;
22260   return jresult;
22261 }
22262
22263
22264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
22265   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22266   size_t arg2 ;
22267   Dali::Texture arg3 ;
22268   Dali::Texture *argp3 ;
22269
22270   arg1 = (Dali::TextureSet *)jarg1;
22271   arg2 = (size_t)jarg2;
22272   argp3 = (Dali::Texture *)jarg3;
22273   if (!argp3) {
22274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
22275     return ;
22276   }
22277   arg3 = *argp3;
22278   {
22279     try {
22280       (arg1)->SetTexture(arg2,arg3);
22281     } catch (std::out_of_range& e) {
22282       {
22283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22284       };
22285     } catch (std::exception& e) {
22286       {
22287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22288       };
22289     } catch (...) {
22290       {
22291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22292       };
22293     }
22294   }
22295 }
22296
22297
22298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
22299   void * jresult ;
22300   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22301   size_t arg2 ;
22302   Dali::Texture result;
22303
22304   arg1 = (Dali::TextureSet *)jarg1;
22305   arg2 = (size_t)jarg2;
22306   {
22307     try {
22308       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
22309     } catch (std::out_of_range& e) {
22310       {
22311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22312       };
22313     } catch (std::exception& e) {
22314       {
22315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22316       };
22317     } catch (...) {
22318       {
22319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22320       };
22321     }
22322   }
22323   jresult = new Dali::Texture((const Dali::Texture &)result);
22324   return jresult;
22325 }
22326
22327
22328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
22329   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22330   size_t arg2 ;
22331   Dali::Sampler arg3 ;
22332   Dali::Sampler *argp3 ;
22333
22334   arg1 = (Dali::TextureSet *)jarg1;
22335   arg2 = (size_t)jarg2;
22336   argp3 = (Dali::Sampler *)jarg3;
22337   if (!argp3) {
22338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
22339     return ;
22340   }
22341   arg3 = *argp3;
22342   {
22343     try {
22344       (arg1)->SetSampler(arg2,arg3);
22345     } catch (std::out_of_range& e) {
22346       {
22347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22348       };
22349     } catch (std::exception& e) {
22350       {
22351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22352       };
22353     } catch (...) {
22354       {
22355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22356       };
22357     }
22358   }
22359 }
22360
22361
22362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
22363   void * jresult ;
22364   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22365   size_t arg2 ;
22366   Dali::Sampler result;
22367
22368   arg1 = (Dali::TextureSet *)jarg1;
22369   arg2 = (size_t)jarg2;
22370   {
22371     try {
22372       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
22373     } catch (std::out_of_range& e) {
22374       {
22375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22376       };
22377     } catch (std::exception& e) {
22378       {
22379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22380       };
22381     } catch (...) {
22382       {
22383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22384       };
22385     }
22386   }
22387   jresult = new Dali::Sampler((const Dali::Sampler &)result);
22388   return jresult;
22389 }
22390
22391
22392 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
22393   unsigned long jresult ;
22394   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
22395   size_t result;
22396
22397   arg1 = (Dali::TextureSet *)jarg1;
22398   {
22399     try {
22400       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
22401     } catch (std::out_of_range& e) {
22402       {
22403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22404       };
22405     } catch (std::exception& e) {
22406       {
22407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22408       };
22409     } catch (...) {
22410       {
22411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22412       };
22413     }
22414   }
22415   jresult = (unsigned long)result;
22416   return jresult;
22417 }
22418
22419
22420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
22421   void * jresult ;
22422   Dali::Property::Map *arg1 = 0 ;
22423   Dali::PropertyBuffer result;
22424
22425   arg1 = (Dali::Property::Map *)jarg1;
22426   if (!arg1) {
22427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
22428     return 0;
22429   }
22430   {
22431     try {
22432       result = Dali::PropertyBuffer::New(*arg1);
22433     } catch (std::out_of_range& e) {
22434       {
22435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22436       };
22437     } catch (std::exception& e) {
22438       {
22439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22440       };
22441     } catch (...) {
22442       {
22443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22444       };
22445     }
22446   }
22447   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22448   return jresult;
22449 }
22450
22451
22452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
22453   void * jresult ;
22454   Dali::PropertyBuffer *result = 0 ;
22455
22456   {
22457     try {
22458       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
22459     } catch (std::out_of_range& e) {
22460       {
22461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22462       };
22463     } catch (std::exception& e) {
22464       {
22465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22466       };
22467     } catch (...) {
22468       {
22469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22470       };
22471     }
22472   }
22473   jresult = (void *)result;
22474   return jresult;
22475 }
22476
22477
22478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
22479   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22480
22481   arg1 = (Dali::PropertyBuffer *)jarg1;
22482   {
22483     try {
22484       delete arg1;
22485     } catch (std::out_of_range& e) {
22486       {
22487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22488       };
22489     } catch (std::exception& e) {
22490       {
22491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22492       };
22493     } catch (...) {
22494       {
22495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22496       };
22497     }
22498   }
22499 }
22500
22501
22502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
22503   void * jresult ;
22504   Dali::PropertyBuffer *arg1 = 0 ;
22505   Dali::PropertyBuffer *result = 0 ;
22506
22507   arg1 = (Dali::PropertyBuffer *)jarg1;
22508   if (!arg1) {
22509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22510     return 0;
22511   }
22512   {
22513     try {
22514       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
22515     } catch (std::out_of_range& e) {
22516       {
22517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22518       };
22519     } catch (std::exception& e) {
22520       {
22521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22522       };
22523     } catch (...) {
22524       {
22525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22526       };
22527     }
22528   }
22529   jresult = (void *)result;
22530   return jresult;
22531 }
22532
22533
22534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
22535   void * jresult ;
22536   Dali::BaseHandle arg1 ;
22537   Dali::BaseHandle *argp1 ;
22538   Dali::PropertyBuffer result;
22539
22540   argp1 = (Dali::BaseHandle *)jarg1;
22541   if (!argp1) {
22542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22543     return 0;
22544   }
22545   arg1 = *argp1;
22546   {
22547     try {
22548       result = Dali::PropertyBuffer::DownCast(arg1);
22549     } catch (std::out_of_range& e) {
22550       {
22551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22552       };
22553     } catch (std::exception& e) {
22554       {
22555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22556       };
22557     } catch (...) {
22558       {
22559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22560       };
22561     }
22562   }
22563   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
22564   return jresult;
22565 }
22566
22567
22568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
22569   void * jresult ;
22570   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22571   Dali::PropertyBuffer *arg2 = 0 ;
22572   Dali::PropertyBuffer *result = 0 ;
22573
22574   arg1 = (Dali::PropertyBuffer *)jarg1;
22575   arg2 = (Dali::PropertyBuffer *)jarg2;
22576   if (!arg2) {
22577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
22578     return 0;
22579   }
22580   {
22581     try {
22582       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
22583     } catch (std::out_of_range& e) {
22584       {
22585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22586       };
22587     } catch (std::exception& e) {
22588       {
22589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22590       };
22591     } catch (...) {
22592       {
22593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22594       };
22595     }
22596   }
22597   jresult = (void *)result;
22598   return jresult;
22599 }
22600
22601
22602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
22603   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22604   void *arg2 = (void *) 0 ;
22605   std::size_t arg3 ;
22606
22607   arg1 = (Dali::PropertyBuffer *)jarg1;
22608   arg2 = jarg2;
22609   arg3 = (std::size_t)jarg3;
22610   {
22611     try {
22612       (arg1)->SetData((void const *)arg2,arg3);
22613     } catch (std::out_of_range& e) {
22614       {
22615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22616       };
22617     } catch (std::exception& e) {
22618       {
22619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22620       };
22621     } catch (...) {
22622       {
22623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22624       };
22625     }
22626   }
22627 }
22628
22629
22630 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
22631   unsigned long jresult ;
22632   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
22633   std::size_t result;
22634
22635   arg1 = (Dali::PropertyBuffer *)jarg1;
22636   {
22637     try {
22638       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
22639     } catch (std::out_of_range& e) {
22640       {
22641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22642       };
22643     } catch (std::exception& e) {
22644       {
22645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22646       };
22647     } catch (...) {
22648       {
22649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22650       };
22651     }
22652   }
22653   jresult = (unsigned long)result;
22654   return jresult;
22655 }
22656
22657
22658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
22659   void * jresult ;
22660   Dali::Geometry result;
22661
22662   {
22663     try {
22664       result = Dali::Geometry::New();
22665     } catch (std::out_of_range& e) {
22666       {
22667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22668       };
22669     } catch (std::exception& e) {
22670       {
22671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22672       };
22673     } catch (...) {
22674       {
22675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22676       };
22677     }
22678   }
22679   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22680   return jresult;
22681 }
22682
22683
22684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
22685   void * jresult ;
22686   Dali::Geometry *result = 0 ;
22687
22688   {
22689     try {
22690       result = (Dali::Geometry *)new Dali::Geometry();
22691     } catch (std::out_of_range& e) {
22692       {
22693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22694       };
22695     } catch (std::exception& e) {
22696       {
22697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22698       };
22699     } catch (...) {
22700       {
22701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22702       };
22703     }
22704   }
22705   jresult = (void *)result;
22706   return jresult;
22707 }
22708
22709
22710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
22711   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22712
22713   arg1 = (Dali::Geometry *)jarg1;
22714   {
22715     try {
22716       delete arg1;
22717     } catch (std::out_of_range& e) {
22718       {
22719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22720       };
22721     } catch (std::exception& e) {
22722       {
22723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22724       };
22725     } catch (...) {
22726       {
22727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22728       };
22729     }
22730   }
22731 }
22732
22733
22734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
22735   void * jresult ;
22736   Dali::Geometry *arg1 = 0 ;
22737   Dali::Geometry *result = 0 ;
22738
22739   arg1 = (Dali::Geometry *)jarg1;
22740   if (!arg1) {
22741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22742     return 0;
22743   }
22744   {
22745     try {
22746       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
22747     } catch (std::out_of_range& e) {
22748       {
22749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22750       };
22751     } catch (std::exception& e) {
22752       {
22753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22754       };
22755     } catch (...) {
22756       {
22757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22758       };
22759     }
22760   }
22761   jresult = (void *)result;
22762   return jresult;
22763 }
22764
22765
22766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
22767   void * jresult ;
22768   Dali::BaseHandle arg1 ;
22769   Dali::BaseHandle *argp1 ;
22770   Dali::Geometry result;
22771
22772   argp1 = (Dali::BaseHandle *)jarg1;
22773   if (!argp1) {
22774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
22775     return 0;
22776   }
22777   arg1 = *argp1;
22778   {
22779     try {
22780       result = Dali::Geometry::DownCast(arg1);
22781     } catch (std::out_of_range& e) {
22782       {
22783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22784       };
22785     } catch (std::exception& e) {
22786       {
22787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22788       };
22789     } catch (...) {
22790       {
22791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22792       };
22793     }
22794   }
22795   jresult = new Dali::Geometry((const Dali::Geometry &)result);
22796   return jresult;
22797 }
22798
22799
22800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
22801   void * jresult ;
22802   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22803   Dali::Geometry *arg2 = 0 ;
22804   Dali::Geometry *result = 0 ;
22805
22806   arg1 = (Dali::Geometry *)jarg1;
22807   arg2 = (Dali::Geometry *)jarg2;
22808   if (!arg2) {
22809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
22810     return 0;
22811   }
22812   {
22813     try {
22814       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
22815     } catch (std::out_of_range& e) {
22816       {
22817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22818       };
22819     } catch (std::exception& e) {
22820       {
22821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22822       };
22823     } catch (...) {
22824       {
22825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22826       };
22827     }
22828   }
22829   jresult = (void *)result;
22830   return jresult;
22831 }
22832
22833
22834 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
22835   unsigned long jresult ;
22836   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22837   Dali::PropertyBuffer *arg2 = 0 ;
22838   std::size_t result;
22839
22840   arg1 = (Dali::Geometry *)jarg1;
22841   arg2 = (Dali::PropertyBuffer *)jarg2;
22842   if (!arg2) {
22843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
22844     return 0;
22845   }
22846   {
22847     try {
22848       result = (arg1)->AddVertexBuffer(*arg2);
22849     } catch (std::out_of_range& e) {
22850       {
22851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22852       };
22853     } catch (std::exception& e) {
22854       {
22855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22856       };
22857     } catch (...) {
22858       {
22859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22860       };
22861     }
22862   }
22863   jresult = (unsigned long)result;
22864   return jresult;
22865 }
22866
22867
22868 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
22869   unsigned long jresult ;
22870   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22871   std::size_t result;
22872
22873   arg1 = (Dali::Geometry *)jarg1;
22874   {
22875     try {
22876       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
22877     } catch (std::out_of_range& e) {
22878       {
22879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22880       };
22881     } catch (std::exception& e) {
22882       {
22883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22884       };
22885     } catch (...) {
22886       {
22887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22888       };
22889     }
22890   }
22891   jresult = (unsigned long)result;
22892   return jresult;
22893 }
22894
22895
22896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
22897   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22898   std::size_t arg2 ;
22899
22900   arg1 = (Dali::Geometry *)jarg1;
22901   arg2 = (std::size_t)jarg2;
22902   {
22903     try {
22904       (arg1)->RemoveVertexBuffer(arg2);
22905     } catch (std::out_of_range& e) {
22906       {
22907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22908       };
22909     } catch (std::exception& e) {
22910       {
22911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22912       };
22913     } catch (...) {
22914       {
22915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22916       };
22917     }
22918   }
22919 }
22920
22921
22922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
22923   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22924   unsigned short *arg2 = (unsigned short *) 0 ;
22925   size_t arg3 ;
22926
22927   arg1 = (Dali::Geometry *)jarg1;
22928   arg2 = jarg2;
22929   arg3 = (size_t)jarg3;
22930   {
22931     try {
22932       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
22933     } catch (std::out_of_range& e) {
22934       {
22935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22936       };
22937     } catch (std::exception& e) {
22938       {
22939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22940       };
22941     } catch (...) {
22942       {
22943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22944       };
22945     }
22946   }
22947
22948
22949 }
22950
22951
22952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
22953   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22954   Dali::Geometry::Type arg2 ;
22955
22956   arg1 = (Dali::Geometry *)jarg1;
22957   arg2 = (Dali::Geometry::Type)jarg2;
22958   {
22959     try {
22960       (arg1)->SetType(arg2);
22961     } catch (std::out_of_range& e) {
22962       {
22963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22964       };
22965     } catch (std::exception& e) {
22966       {
22967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22968       };
22969     } catch (...) {
22970       {
22971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22972       };
22973     }
22974   }
22975 }
22976
22977
22978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
22979   int jresult ;
22980   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
22981   Dali::Geometry::Type result;
22982
22983   arg1 = (Dali::Geometry *)jarg1;
22984   {
22985     try {
22986       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
22987     } catch (std::out_of_range& e) {
22988       {
22989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22990       };
22991     } catch (std::exception& e) {
22992       {
22993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22994       };
22995     } catch (...) {
22996       {
22997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22998       };
22999     }
23000   }
23001   jresult = (int)result;
23002   return jresult;
23003 }
23004
23005
23006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
23007   void * jresult ;
23008   Dali::Shader::Hint *result = 0 ;
23009
23010   {
23011     try {
23012       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
23013     } catch (std::out_of_range& e) {
23014       {
23015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23016       };
23017     } catch (std::exception& e) {
23018       {
23019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23020       };
23021     } catch (...) {
23022       {
23023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23024       };
23025     }
23026   }
23027   jresult = (void *)result;
23028   return jresult;
23029 }
23030
23031
23032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
23033   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
23034
23035   arg1 = (Dali::Shader::Hint *)jarg1;
23036   {
23037     try {
23038       delete arg1;
23039     } catch (std::out_of_range& e) {
23040       {
23041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23042       };
23043     } catch (std::exception& e) {
23044       {
23045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23046       };
23047     } catch (...) {
23048       {
23049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23050       };
23051     }
23052   }
23053 }
23054
23055
23056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
23057   int jresult ;
23058   int result;
23059
23060   result = (int)Dali::Shader::Property::PROGRAM;
23061   jresult = (int)result;
23062   return jresult;
23063 }
23064
23065
23066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
23067   void * jresult ;
23068   Dali::Shader::Property *result = 0 ;
23069
23070   {
23071     try {
23072       result = (Dali::Shader::Property *)new Dali::Shader::Property();
23073     } catch (std::out_of_range& e) {
23074       {
23075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23076       };
23077     } catch (std::exception& e) {
23078       {
23079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23080       };
23081     } catch (...) {
23082       {
23083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23084       };
23085     }
23086   }
23087   jresult = (void *)result;
23088   return jresult;
23089 }
23090
23091
23092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
23093   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
23094
23095   arg1 = (Dali::Shader::Property *)jarg1;
23096   {
23097     try {
23098       delete arg1;
23099     } catch (std::out_of_range& e) {
23100       {
23101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23102       };
23103     } catch (std::exception& e) {
23104       {
23105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23106       };
23107     } catch (...) {
23108       {
23109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23110       };
23111     }
23112   }
23113 }
23114
23115
23116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
23117   void * jresult ;
23118   std::string *arg1 = 0 ;
23119   std::string *arg2 = 0 ;
23120   Dali::Shader::Hint::Value arg3 ;
23121   Dali::Shader result;
23122
23123   if (!jarg1) {
23124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23125     return 0;
23126   }
23127   std::string arg1_str(jarg1);
23128   arg1 = &arg1_str;
23129   if (!jarg2) {
23130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23131     return 0;
23132   }
23133   std::string arg2_str(jarg2);
23134   arg2 = &arg2_str;
23135   arg3 = (Dali::Shader::Hint::Value)jarg3;
23136   {
23137     try {
23138       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
23139     } catch (std::out_of_range& e) {
23140       {
23141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23142       };
23143     } catch (std::exception& e) {
23144       {
23145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23146       };
23147     } catch (...) {
23148       {
23149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23150       };
23151     }
23152   }
23153   jresult = new Dali::Shader((const Dali::Shader &)result);
23154
23155   //argout typemap for const std::string&
23156
23157
23158   //argout typemap for const std::string&
23159
23160   return jresult;
23161 }
23162
23163
23164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
23165   void * jresult ;
23166   std::string *arg1 = 0 ;
23167   std::string *arg2 = 0 ;
23168   Dali::Shader result;
23169
23170   if (!jarg1) {
23171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23172     return 0;
23173   }
23174   std::string arg1_str(jarg1);
23175   arg1 = &arg1_str;
23176   if (!jarg2) {
23177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
23178     return 0;
23179   }
23180   std::string arg2_str(jarg2);
23181   arg2 = &arg2_str;
23182   {
23183     try {
23184       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
23185     } catch (std::out_of_range& e) {
23186       {
23187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23188       };
23189     } catch (std::exception& e) {
23190       {
23191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23192       };
23193     } catch (...) {
23194       {
23195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23196       };
23197     }
23198   }
23199   jresult = new Dali::Shader((const Dali::Shader &)result);
23200
23201   //argout typemap for const std::string&
23202
23203
23204   //argout typemap for const std::string&
23205
23206   return jresult;
23207 }
23208
23209
23210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
23211   void * jresult ;
23212   Dali::Shader *result = 0 ;
23213
23214   {
23215     try {
23216       result = (Dali::Shader *)new Dali::Shader();
23217     } catch (std::out_of_range& e) {
23218       {
23219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23220       };
23221     } catch (std::exception& e) {
23222       {
23223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23224       };
23225     } catch (...) {
23226       {
23227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23228       };
23229     }
23230   }
23231   jresult = (void *)result;
23232   return jresult;
23233 }
23234
23235
23236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
23237   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23238
23239   arg1 = (Dali::Shader *)jarg1;
23240   {
23241     try {
23242       delete arg1;
23243     } catch (std::out_of_range& e) {
23244       {
23245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23246       };
23247     } catch (std::exception& e) {
23248       {
23249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23250       };
23251     } catch (...) {
23252       {
23253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23254       };
23255     }
23256   }
23257 }
23258
23259
23260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
23261   void * jresult ;
23262   Dali::Shader *arg1 = 0 ;
23263   Dali::Shader *result = 0 ;
23264
23265   arg1 = (Dali::Shader *)jarg1;
23266   if (!arg1) {
23267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23268     return 0;
23269   }
23270   {
23271     try {
23272       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
23273     } catch (std::out_of_range& e) {
23274       {
23275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23276       };
23277     } catch (std::exception& e) {
23278       {
23279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23280       };
23281     } catch (...) {
23282       {
23283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23284       };
23285     }
23286   }
23287   jresult = (void *)result;
23288   return jresult;
23289 }
23290
23291
23292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
23293   void * jresult ;
23294   Dali::BaseHandle arg1 ;
23295   Dali::BaseHandle *argp1 ;
23296   Dali::Shader result;
23297
23298   argp1 = (Dali::BaseHandle *)jarg1;
23299   if (!argp1) {
23300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23301     return 0;
23302   }
23303   arg1 = *argp1;
23304   {
23305     try {
23306       result = Dali::Shader::DownCast(arg1);
23307     } catch (std::out_of_range& e) {
23308       {
23309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23310       };
23311     } catch (std::exception& e) {
23312       {
23313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23314       };
23315     } catch (...) {
23316       {
23317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23318       };
23319     }
23320   }
23321   jresult = new Dali::Shader((const Dali::Shader &)result);
23322   return jresult;
23323 }
23324
23325
23326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
23327   void * jresult ;
23328   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
23329   Dali::Shader *arg2 = 0 ;
23330   Dali::Shader *result = 0 ;
23331
23332   arg1 = (Dali::Shader *)jarg1;
23333   arg2 = (Dali::Shader *)jarg2;
23334   if (!arg2) {
23335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
23336     return 0;
23337   }
23338   {
23339     try {
23340       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
23341     } catch (std::out_of_range& e) {
23342       {
23343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23344       };
23345     } catch (std::exception& e) {
23346       {
23347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23348       };
23349     } catch (...) {
23350       {
23351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23352       };
23353     }
23354   }
23355   jresult = (void *)result;
23356   return jresult;
23357 }
23358
23359
23360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
23361   int jresult ;
23362   int result;
23363
23364   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
23365   jresult = (int)result;
23366   return jresult;
23367 }
23368
23369
23370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
23371   int jresult ;
23372   int result;
23373
23374   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
23375   jresult = (int)result;
23376   return jresult;
23377 }
23378
23379
23380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
23381   int jresult ;
23382   int result;
23383
23384   result = (int)Dali::Renderer::Property::BLEND_MODE;
23385   jresult = (int)result;
23386   return jresult;
23387 }
23388
23389
23390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
23391   int jresult ;
23392   int result;
23393
23394   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
23395   jresult = (int)result;
23396   return jresult;
23397 }
23398
23399
23400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
23401   int jresult ;
23402   int result;
23403
23404   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
23405   jresult = (int)result;
23406   return jresult;
23407 }
23408
23409
23410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
23411   int jresult ;
23412   int result;
23413
23414   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
23415   jresult = (int)result;
23416   return jresult;
23417 }
23418
23419
23420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
23421   int jresult ;
23422   int result;
23423
23424   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
23425   jresult = (int)result;
23426   return jresult;
23427 }
23428
23429
23430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
23431   int jresult ;
23432   int result;
23433
23434   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
23435   jresult = (int)result;
23436   return jresult;
23437 }
23438
23439
23440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
23441   int jresult ;
23442   int result;
23443
23444   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
23445   jresult = (int)result;
23446   return jresult;
23447 }
23448
23449
23450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
23451   int jresult ;
23452   int result;
23453
23454   result = (int)Dali::Renderer::Property::BLEND_COLOR;
23455   jresult = (int)result;
23456   return jresult;
23457 }
23458
23459
23460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
23461   int jresult ;
23462   int result;
23463
23464   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
23465   jresult = (int)result;
23466   return jresult;
23467 }
23468
23469
23470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
23471   int jresult ;
23472   int result;
23473
23474   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
23475   jresult = (int)result;
23476   return jresult;
23477 }
23478
23479
23480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
23481   int jresult ;
23482   int result;
23483
23484   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
23485   jresult = (int)result;
23486   return jresult;
23487 }
23488
23489
23490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
23491   int jresult ;
23492   int result;
23493
23494   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
23495   jresult = (int)result;
23496   return jresult;
23497 }
23498
23499
23500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
23501   int jresult ;
23502   int result;
23503
23504   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
23505   jresult = (int)result;
23506   return jresult;
23507 }
23508
23509
23510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
23511   int jresult ;
23512   int result;
23513
23514   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
23515   jresult = (int)result;
23516   return jresult;
23517 }
23518
23519
23520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
23521   int jresult ;
23522   int result;
23523
23524   result = (int)Dali::Renderer::Property::RENDER_MODE;
23525   jresult = (int)result;
23526   return jresult;
23527 }
23528
23529
23530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
23531   int jresult ;
23532   int result;
23533
23534   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
23535   jresult = (int)result;
23536   return jresult;
23537 }
23538
23539
23540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
23541   int jresult ;
23542   int result;
23543
23544   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
23545   jresult = (int)result;
23546   return jresult;
23547 }
23548
23549
23550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
23551   int jresult ;
23552   int result;
23553
23554   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
23555   jresult = (int)result;
23556   return jresult;
23557 }
23558
23559
23560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
23561   int jresult ;
23562   int result;
23563
23564   result = (int)Dali::Renderer::Property::STENCIL_MASK;
23565   jresult = (int)result;
23566   return jresult;
23567 }
23568
23569
23570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
23571   int jresult ;
23572   int result;
23573
23574   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
23575   jresult = (int)result;
23576   return jresult;
23577 }
23578
23579
23580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
23581   int jresult ;
23582   int result;
23583
23584   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
23585   jresult = (int)result;
23586   return jresult;
23587 }
23588
23589
23590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
23591   int jresult ;
23592   int result;
23593
23594   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
23595   jresult = (int)result;
23596   return jresult;
23597 }
23598
23599
23600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
23601   void * jresult ;
23602   Dali::Renderer::Property *result = 0 ;
23603
23604   {
23605     try {
23606       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
23607     } catch (std::out_of_range& e) {
23608       {
23609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23610       };
23611     } catch (std::exception& e) {
23612       {
23613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23614       };
23615     } catch (...) {
23616       {
23617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23618       };
23619     }
23620   }
23621   jresult = (void *)result;
23622   return jresult;
23623 }
23624
23625
23626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
23627   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
23628
23629   arg1 = (Dali::Renderer::Property *)jarg1;
23630   {
23631     try {
23632       delete arg1;
23633     } catch (std::out_of_range& e) {
23634       {
23635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23636       };
23637     } catch (std::exception& e) {
23638       {
23639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23640       };
23641     } catch (...) {
23642       {
23643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23644       };
23645     }
23646   }
23647 }
23648
23649
23650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
23651   void * jresult ;
23652   Dali::Geometry *arg1 = 0 ;
23653   Dali::Shader *arg2 = 0 ;
23654   Dali::Renderer result;
23655
23656   arg1 = (Dali::Geometry *)jarg1;
23657   if (!arg1) {
23658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23659     return 0;
23660   }
23661   arg2 = (Dali::Shader *)jarg2;
23662   if (!arg2) {
23663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23664     return 0;
23665   }
23666   {
23667     try {
23668       result = Dali::Renderer::New(*arg1,*arg2);
23669     } catch (std::out_of_range& e) {
23670       {
23671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23672       };
23673     } catch (std::exception& e) {
23674       {
23675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23676       };
23677     } catch (...) {
23678       {
23679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23680       };
23681     }
23682   }
23683   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23684   return jresult;
23685 }
23686
23687
23688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
23689   void * jresult ;
23690   Dali::Renderer *result = 0 ;
23691
23692   {
23693     try {
23694       result = (Dali::Renderer *)new Dali::Renderer();
23695     } catch (std::out_of_range& e) {
23696       {
23697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23698       };
23699     } catch (std::exception& e) {
23700       {
23701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23702       };
23703     } catch (...) {
23704       {
23705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23706       };
23707     }
23708   }
23709   jresult = (void *)result;
23710   return jresult;
23711 }
23712
23713
23714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
23715   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23716
23717   arg1 = (Dali::Renderer *)jarg1;
23718   {
23719     try {
23720       delete arg1;
23721     } catch (std::out_of_range& e) {
23722       {
23723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23724       };
23725     } catch (std::exception& e) {
23726       {
23727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23728       };
23729     } catch (...) {
23730       {
23731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23732       };
23733     }
23734   }
23735 }
23736
23737
23738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
23739   void * jresult ;
23740   Dali::Renderer *arg1 = 0 ;
23741   Dali::Renderer *result = 0 ;
23742
23743   arg1 = (Dali::Renderer *)jarg1;
23744   if (!arg1) {
23745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23746     return 0;
23747   }
23748   {
23749     try {
23750       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
23751     } catch (std::out_of_range& e) {
23752       {
23753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23754       };
23755     } catch (std::exception& e) {
23756       {
23757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23758       };
23759     } catch (...) {
23760       {
23761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23762       };
23763     }
23764   }
23765   jresult = (void *)result;
23766   return jresult;
23767 }
23768
23769
23770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
23771   void * jresult ;
23772   Dali::BaseHandle arg1 ;
23773   Dali::BaseHandle *argp1 ;
23774   Dali::Renderer result;
23775
23776   argp1 = (Dali::BaseHandle *)jarg1;
23777   if (!argp1) {
23778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23779     return 0;
23780   }
23781   arg1 = *argp1;
23782   {
23783     try {
23784       result = Dali::Renderer::DownCast(arg1);
23785     } catch (std::out_of_range& e) {
23786       {
23787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23788       };
23789     } catch (std::exception& e) {
23790       {
23791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23792       };
23793     } catch (...) {
23794       {
23795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23796       };
23797     }
23798   }
23799   jresult = new Dali::Renderer((const Dali::Renderer &)result);
23800   return jresult;
23801 }
23802
23803
23804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
23805   void * jresult ;
23806   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23807   Dali::Renderer *arg2 = 0 ;
23808   Dali::Renderer *result = 0 ;
23809
23810   arg1 = (Dali::Renderer *)jarg1;
23811   arg2 = (Dali::Renderer *)jarg2;
23812   if (!arg2) {
23813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
23814     return 0;
23815   }
23816   {
23817     try {
23818       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
23819     } catch (std::out_of_range& e) {
23820       {
23821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23822       };
23823     } catch (std::exception& e) {
23824       {
23825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23826       };
23827     } catch (...) {
23828       {
23829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23830       };
23831     }
23832   }
23833   jresult = (void *)result;
23834   return jresult;
23835 }
23836
23837
23838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
23839   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23840   Dali::Geometry *arg2 = 0 ;
23841
23842   arg1 = (Dali::Renderer *)jarg1;
23843   arg2 = (Dali::Geometry *)jarg2;
23844   if (!arg2) {
23845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
23846     return ;
23847   }
23848   {
23849     try {
23850       (arg1)->SetGeometry(*arg2);
23851     } catch (std::out_of_range& e) {
23852       {
23853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23854       };
23855     } catch (std::exception& e) {
23856       {
23857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23858       };
23859     } catch (...) {
23860       {
23861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23862       };
23863     }
23864   }
23865 }
23866
23867
23868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
23869   void * jresult ;
23870   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23871   Dali::Geometry result;
23872
23873   arg1 = (Dali::Renderer *)jarg1;
23874   {
23875     try {
23876       result = ((Dali::Renderer const *)arg1)->GetGeometry();
23877     } catch (std::out_of_range& e) {
23878       {
23879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23880       };
23881     } catch (std::exception& e) {
23882       {
23883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23884       };
23885     } catch (...) {
23886       {
23887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23888       };
23889     }
23890   }
23891   jresult = new Dali::Geometry((const Dali::Geometry &)result);
23892   return jresult;
23893 }
23894
23895
23896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
23897   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23898   int arg2 ;
23899   int arg3 ;
23900
23901   arg1 = (Dali::Renderer *)jarg1;
23902   arg2 = (int)jarg2;
23903   arg3 = (int)jarg3;
23904   {
23905     try {
23906       (arg1)->SetIndexRange(arg2,arg3);
23907     } catch (std::out_of_range& e) {
23908       {
23909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23910       };
23911     } catch (std::exception& e) {
23912       {
23913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23914       };
23915     } catch (...) {
23916       {
23917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23918       };
23919     }
23920   }
23921 }
23922
23923
23924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
23925   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23926   Dali::TextureSet *arg2 = 0 ;
23927
23928   arg1 = (Dali::Renderer *)jarg1;
23929   arg2 = (Dali::TextureSet *)jarg2;
23930   if (!arg2) {
23931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
23932     return ;
23933   }
23934   {
23935     try {
23936       (arg1)->SetTextures(*arg2);
23937     } catch (std::out_of_range& e) {
23938       {
23939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23940       };
23941     } catch (std::exception& e) {
23942       {
23943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23944       };
23945     } catch (...) {
23946       {
23947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23948       };
23949     }
23950   }
23951 }
23952
23953
23954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
23955   void * jresult ;
23956   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23957   Dali::TextureSet result;
23958
23959   arg1 = (Dali::Renderer *)jarg1;
23960   {
23961     try {
23962       result = ((Dali::Renderer const *)arg1)->GetTextures();
23963     } catch (std::out_of_range& e) {
23964       {
23965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23966       };
23967     } catch (std::exception& e) {
23968       {
23969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23970       };
23971     } catch (...) {
23972       {
23973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23974       };
23975     }
23976   }
23977   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
23978   return jresult;
23979 }
23980
23981
23982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
23983   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
23984   Dali::Shader *arg2 = 0 ;
23985
23986   arg1 = (Dali::Renderer *)jarg1;
23987   arg2 = (Dali::Shader *)jarg2;
23988   if (!arg2) {
23989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
23990     return ;
23991   }
23992   {
23993     try {
23994       (arg1)->SetShader(*arg2);
23995     } catch (std::out_of_range& e) {
23996       {
23997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23998       };
23999     } catch (std::exception& e) {
24000       {
24001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24002       };
24003     } catch (...) {
24004       {
24005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24006       };
24007     }
24008   }
24009 }
24010
24011
24012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
24013   void * jresult ;
24014   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
24015   Dali::Shader result;
24016
24017   arg1 = (Dali::Renderer *)jarg1;
24018   {
24019     try {
24020       result = ((Dali::Renderer const *)arg1)->GetShader();
24021     } catch (std::out_of_range& e) {
24022       {
24023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24024       };
24025     } catch (std::exception& e) {
24026       {
24027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24028       };
24029     } catch (...) {
24030       {
24031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24032       };
24033     }
24034   }
24035   jresult = new Dali::Shader((const Dali::Shader &)result);
24036   return jresult;
24037 }
24038
24039
24040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
24041   void * jresult ;
24042   Dali::FrameBuffer::Attachment *result = 0 ;
24043
24044   {
24045     try {
24046       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
24047     } catch (std::out_of_range& e) {
24048       {
24049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24050       };
24051     } catch (std::exception& e) {
24052       {
24053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24054       };
24055     } catch (...) {
24056       {
24057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24058       };
24059     }
24060   }
24061   jresult = (void *)result;
24062   return jresult;
24063 }
24064
24065
24066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
24067   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
24068
24069   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
24070   {
24071     try {
24072       delete arg1;
24073     } catch (std::out_of_range& e) {
24074       {
24075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24076       };
24077     } catch (std::exception& e) {
24078       {
24079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24080       };
24081     } catch (...) {
24082       {
24083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24084       };
24085     }
24086   }
24087 }
24088
24089
24090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
24091   void * jresult ;
24092   unsigned int arg1 ;
24093   unsigned int arg2 ;
24094   unsigned int arg3 ;
24095   Dali::FrameBuffer result;
24096
24097   arg1 = (unsigned int)jarg1;
24098   arg2 = (unsigned int)jarg2;
24099   arg3 = (unsigned int)jarg3;
24100   {
24101     try {
24102       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
24103     } catch (std::out_of_range& e) {
24104       {
24105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24106       };
24107     } catch (std::exception& e) {
24108       {
24109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24110       };
24111     } catch (...) {
24112       {
24113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24114       };
24115     }
24116   }
24117   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24118   return jresult;
24119 }
24120
24121
24122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
24123   void * jresult ;
24124   Dali::FrameBuffer *result = 0 ;
24125
24126   {
24127     try {
24128       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
24129     } catch (std::out_of_range& e) {
24130       {
24131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24132       };
24133     } catch (std::exception& e) {
24134       {
24135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24136       };
24137     } catch (...) {
24138       {
24139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24140       };
24141     }
24142   }
24143   jresult = (void *)result;
24144   return jresult;
24145 }
24146
24147
24148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
24149   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24150
24151   arg1 = (Dali::FrameBuffer *)jarg1;
24152   {
24153     try {
24154       delete arg1;
24155     } catch (std::out_of_range& e) {
24156       {
24157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24158       };
24159     } catch (std::exception& e) {
24160       {
24161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24162       };
24163     } catch (...) {
24164       {
24165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24166       };
24167     }
24168   }
24169 }
24170
24171
24172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
24173   void * jresult ;
24174   Dali::FrameBuffer *arg1 = 0 ;
24175   Dali::FrameBuffer *result = 0 ;
24176
24177   arg1 = (Dali::FrameBuffer *)jarg1;
24178   if (!arg1) {
24179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24180     return 0;
24181   }
24182   {
24183     try {
24184       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
24185     } catch (std::out_of_range& e) {
24186       {
24187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24188       };
24189     } catch (std::exception& e) {
24190       {
24191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24192       };
24193     } catch (...) {
24194       {
24195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24196       };
24197     }
24198   }
24199   jresult = (void *)result;
24200   return jresult;
24201 }
24202
24203
24204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
24205   void * jresult ;
24206   Dali::BaseHandle arg1 ;
24207   Dali::BaseHandle *argp1 ;
24208   Dali::FrameBuffer result;
24209
24210   argp1 = (Dali::BaseHandle *)jarg1;
24211   if (!argp1) {
24212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24213     return 0;
24214   }
24215   arg1 = *argp1;
24216   {
24217     try {
24218       result = Dali::FrameBuffer::DownCast(arg1);
24219     } catch (std::out_of_range& e) {
24220       {
24221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24222       };
24223     } catch (std::exception& e) {
24224       {
24225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24226       };
24227     } catch (...) {
24228       {
24229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24230       };
24231     }
24232   }
24233   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
24234   return jresult;
24235 }
24236
24237
24238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
24239   void * jresult ;
24240   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24241   Dali::FrameBuffer *arg2 = 0 ;
24242   Dali::FrameBuffer *result = 0 ;
24243
24244   arg1 = (Dali::FrameBuffer *)jarg1;
24245   arg2 = (Dali::FrameBuffer *)jarg2;
24246   if (!arg2) {
24247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
24248     return 0;
24249   }
24250   {
24251     try {
24252       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
24253     } catch (std::out_of_range& e) {
24254       {
24255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24256       };
24257     } catch (std::exception& e) {
24258       {
24259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24260       };
24261     } catch (...) {
24262       {
24263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24264       };
24265     }
24266   }
24267   jresult = (void *)result;
24268   return jresult;
24269 }
24270
24271
24272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
24273   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24274   Dali::Texture *arg2 = 0 ;
24275
24276   arg1 = (Dali::FrameBuffer *)jarg1;
24277   arg2 = (Dali::Texture *)jarg2;
24278   if (!arg2) {
24279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24280     return ;
24281   }
24282   {
24283     try {
24284       (arg1)->AttachColorTexture(*arg2);
24285     } catch (std::out_of_range& e) {
24286       {
24287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24288       };
24289     } catch (std::exception& e) {
24290       {
24291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24292       };
24293     } catch (...) {
24294       {
24295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24296       };
24297     }
24298   }
24299 }
24300
24301
24302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
24303   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24304   Dali::Texture *arg2 = 0 ;
24305   unsigned int arg3 ;
24306   unsigned int arg4 ;
24307
24308   arg1 = (Dali::FrameBuffer *)jarg1;
24309   arg2 = (Dali::Texture *)jarg2;
24310   if (!arg2) {
24311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
24312     return ;
24313   }
24314   arg3 = (unsigned int)jarg3;
24315   arg4 = (unsigned int)jarg4;
24316   {
24317     try {
24318       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
24319     } catch (std::out_of_range& e) {
24320       {
24321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24322       };
24323     } catch (std::exception& e) {
24324       {
24325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24326       };
24327     } catch (...) {
24328       {
24329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24330       };
24331     }
24332   }
24333 }
24334
24335
24336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
24337   void * jresult ;
24338   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
24339   Dali::Texture result;
24340
24341   arg1 = (Dali::FrameBuffer *)jarg1;
24342   {
24343     try {
24344       result = (arg1)->GetColorTexture();
24345     } catch (std::out_of_range& e) {
24346       {
24347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24348       };
24349     } catch (std::exception& e) {
24350       {
24351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24352       };
24353     } catch (...) {
24354       {
24355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24356       };
24357     }
24358   }
24359   jresult = new Dali::Texture((const Dali::Texture &)result);
24360   return jresult;
24361 }
24362
24363
24364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
24365   void * jresult ;
24366   Dali::RenderTaskList *result = 0 ;
24367
24368   {
24369     try {
24370       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
24371     } catch (std::out_of_range& e) {
24372       {
24373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24374       };
24375     } catch (std::exception& e) {
24376       {
24377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24378       };
24379     } catch (...) {
24380       {
24381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24382       };
24383     }
24384   }
24385   jresult = (void *)result;
24386   return jresult;
24387 }
24388
24389
24390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
24391   void * jresult ;
24392   Dali::BaseHandle arg1 ;
24393   Dali::BaseHandle *argp1 ;
24394   Dali::RenderTaskList result;
24395
24396   argp1 = (Dali::BaseHandle *)jarg1;
24397   if (!argp1) {
24398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24399     return 0;
24400   }
24401   arg1 = *argp1;
24402   {
24403     try {
24404       result = Dali::RenderTaskList::DownCast(arg1);
24405     } catch (std::out_of_range& e) {
24406       {
24407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24408       };
24409     } catch (std::exception& e) {
24410       {
24411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24412       };
24413     } catch (...) {
24414       {
24415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24416       };
24417     }
24418   }
24419   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
24420   return jresult;
24421 }
24422
24423
24424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
24425   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24426
24427   arg1 = (Dali::RenderTaskList *)jarg1;
24428   {
24429     try {
24430       delete arg1;
24431     } catch (std::out_of_range& e) {
24432       {
24433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24434       };
24435     } catch (std::exception& e) {
24436       {
24437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24438       };
24439     } catch (...) {
24440       {
24441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24442       };
24443     }
24444   }
24445 }
24446
24447
24448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
24449   void * jresult ;
24450   Dali::RenderTaskList *arg1 = 0 ;
24451   Dali::RenderTaskList *result = 0 ;
24452
24453   arg1 = (Dali::RenderTaskList *)jarg1;
24454   if (!arg1) {
24455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24456     return 0;
24457   }
24458   {
24459     try {
24460       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
24461     } catch (std::out_of_range& e) {
24462       {
24463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24464       };
24465     } catch (std::exception& e) {
24466       {
24467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24468       };
24469     } catch (...) {
24470       {
24471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24472       };
24473     }
24474   }
24475   jresult = (void *)result;
24476   return jresult;
24477 }
24478
24479
24480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
24481   void * jresult ;
24482   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24483   Dali::RenderTaskList *arg2 = 0 ;
24484   Dali::RenderTaskList *result = 0 ;
24485
24486   arg1 = (Dali::RenderTaskList *)jarg1;
24487   arg2 = (Dali::RenderTaskList *)jarg2;
24488   if (!arg2) {
24489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
24490     return 0;
24491   }
24492   {
24493     try {
24494       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
24495     } catch (std::out_of_range& e) {
24496       {
24497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24498       };
24499     } catch (std::exception& e) {
24500       {
24501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24502       };
24503     } catch (...) {
24504       {
24505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24506       };
24507     }
24508   }
24509   jresult = (void *)result;
24510   return jresult;
24511 }
24512
24513
24514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
24515   void * jresult ;
24516   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24517   Dali::RenderTask result;
24518
24519   arg1 = (Dali::RenderTaskList *)jarg1;
24520   {
24521     try {
24522       result = (arg1)->CreateTask();
24523     } catch (std::out_of_range& e) {
24524       {
24525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24526       };
24527     } catch (std::exception& e) {
24528       {
24529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24530       };
24531     } catch (...) {
24532       {
24533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24534       };
24535     }
24536   }
24537   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24538   return jresult;
24539 }
24540
24541
24542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
24543   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24544   Dali::RenderTask arg2 ;
24545   Dali::RenderTask *argp2 ;
24546
24547   arg1 = (Dali::RenderTaskList *)jarg1;
24548   argp2 = (Dali::RenderTask *)jarg2;
24549   if (!argp2) {
24550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
24551     return ;
24552   }
24553   arg2 = *argp2;
24554   {
24555     try {
24556       (arg1)->RemoveTask(arg2);
24557     } catch (std::out_of_range& e) {
24558       {
24559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24560       };
24561     } catch (std::exception& e) {
24562       {
24563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24564       };
24565     } catch (...) {
24566       {
24567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24568       };
24569     }
24570   }
24571 }
24572
24573
24574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
24575   unsigned int jresult ;
24576   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24577   unsigned int result;
24578
24579   arg1 = (Dali::RenderTaskList *)jarg1;
24580   {
24581     try {
24582       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
24583     } catch (std::out_of_range& e) {
24584       {
24585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24586       };
24587     } catch (std::exception& e) {
24588       {
24589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24590       };
24591     } catch (...) {
24592       {
24593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24594       };
24595     }
24596   }
24597   jresult = result;
24598   return jresult;
24599 }
24600
24601
24602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
24603   void * jresult ;
24604   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
24605   unsigned int arg2 ;
24606   Dali::RenderTask result;
24607
24608   arg1 = (Dali::RenderTaskList *)jarg1;
24609   arg2 = (unsigned int)jarg2;
24610   {
24611     try {
24612       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
24613     } catch (std::out_of_range& e) {
24614       {
24615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24616       };
24617     } catch (std::exception& e) {
24618       {
24619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24620       };
24621     } catch (...) {
24622       {
24623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24624       };
24625     }
24626   }
24627   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24628   return jresult;
24629 }
24630
24631
24632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
24633   int jresult ;
24634   int result;
24635
24636   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
24637   jresult = (int)result;
24638   return jresult;
24639 }
24640
24641
24642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
24643   int jresult ;
24644   int result;
24645
24646   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
24647   jresult = (int)result;
24648   return jresult;
24649 }
24650
24651
24652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
24653   int jresult ;
24654   int result;
24655
24656   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
24657   jresult = (int)result;
24658   return jresult;
24659 }
24660
24661
24662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
24663   int jresult ;
24664   int result;
24665
24666   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
24667   jresult = (int)result;
24668   return jresult;
24669 }
24670
24671
24672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
24673   void * jresult ;
24674   Dali::RenderTask::Property *result = 0 ;
24675
24676   {
24677     try {
24678       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
24679     } catch (std::out_of_range& e) {
24680       {
24681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24682       };
24683     } catch (std::exception& e) {
24684       {
24685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24686       };
24687     } catch (...) {
24688       {
24689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24690       };
24691     }
24692   }
24693   jresult = (void *)result;
24694   return jresult;
24695 }
24696
24697
24698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
24699   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
24700
24701   arg1 = (Dali::RenderTask::Property *)jarg1;
24702   {
24703     try {
24704       delete arg1;
24705     } catch (std::out_of_range& e) {
24706       {
24707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24708       };
24709     } catch (std::exception& e) {
24710       {
24711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24712       };
24713     } catch (...) {
24714       {
24715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24716       };
24717     }
24718   }
24719 }
24720
24721
24722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
24723   void * jresult ;
24724   bool (*result)(Dali::Vector2 &) = 0 ;
24725
24726   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
24727   jresult = (void *)result;
24728   return jresult;
24729 }
24730
24731
24732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
24733   void * jresult ;
24734   bool (*result)(Dali::Vector2 &) = 0 ;
24735
24736   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
24737   jresult = (void *)result;
24738   return jresult;
24739 }
24740
24741
24742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
24743   unsigned int jresult ;
24744   bool result;
24745
24746   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
24747   jresult = result;
24748   return jresult;
24749 }
24750
24751
24752 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
24753   unsigned int jresult ;
24754   bool result;
24755
24756   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
24757   jresult = result;
24758   return jresult;
24759 }
24760
24761
24762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
24763   void * jresult ;
24764   Dali::Vector4 *result = 0 ;
24765
24766   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
24767   jresult = (void *)result;
24768   return jresult;
24769 }
24770
24771
24772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
24773   unsigned int jresult ;
24774   bool result;
24775
24776   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
24777   jresult = result;
24778   return jresult;
24779 }
24780
24781
24782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
24783   unsigned int jresult ;
24784   bool result;
24785
24786   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
24787   jresult = result;
24788   return jresult;
24789 }
24790
24791
24792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
24793   unsigned int jresult ;
24794   unsigned int result;
24795
24796   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
24797   jresult = result;
24798   return jresult;
24799 }
24800
24801
24802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
24803   void * jresult ;
24804   Dali::RenderTask *result = 0 ;
24805
24806   {
24807     try {
24808       result = (Dali::RenderTask *)new Dali::RenderTask();
24809     } catch (std::out_of_range& e) {
24810       {
24811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24812       };
24813     } catch (std::exception& e) {
24814       {
24815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24816       };
24817     } catch (...) {
24818       {
24819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24820       };
24821     }
24822   }
24823   jresult = (void *)result;
24824   return jresult;
24825 }
24826
24827
24828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
24829   void * jresult ;
24830   Dali::BaseHandle arg1 ;
24831   Dali::BaseHandle *argp1 ;
24832   Dali::RenderTask result;
24833
24834   argp1 = (Dali::BaseHandle *)jarg1;
24835   if (!argp1) {
24836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24837     return 0;
24838   }
24839   arg1 = *argp1;
24840   {
24841     try {
24842       result = Dali::RenderTask::DownCast(arg1);
24843     } catch (std::out_of_range& e) {
24844       {
24845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24846       };
24847     } catch (std::exception& e) {
24848       {
24849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24850       };
24851     } catch (...) {
24852       {
24853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24854       };
24855     }
24856   }
24857   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
24858   return jresult;
24859 }
24860
24861
24862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
24863   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24864
24865   arg1 = (Dali::RenderTask *)jarg1;
24866   {
24867     try {
24868       delete arg1;
24869     } catch (std::out_of_range& e) {
24870       {
24871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24872       };
24873     } catch (std::exception& e) {
24874       {
24875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24876       };
24877     } catch (...) {
24878       {
24879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24880       };
24881     }
24882   }
24883 }
24884
24885
24886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
24887   void * jresult ;
24888   Dali::RenderTask *arg1 = 0 ;
24889   Dali::RenderTask *result = 0 ;
24890
24891   arg1 = (Dali::RenderTask *)jarg1;
24892   if (!arg1) {
24893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24894     return 0;
24895   }
24896   {
24897     try {
24898       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
24899     } catch (std::out_of_range& e) {
24900       {
24901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24902       };
24903     } catch (std::exception& e) {
24904       {
24905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24906       };
24907     } catch (...) {
24908       {
24909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24910       };
24911     }
24912   }
24913   jresult = (void *)result;
24914   return jresult;
24915 }
24916
24917
24918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
24919   void * jresult ;
24920   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24921   Dali::RenderTask *arg2 = 0 ;
24922   Dali::RenderTask *result = 0 ;
24923
24924   arg1 = (Dali::RenderTask *)jarg1;
24925   arg2 = (Dali::RenderTask *)jarg2;
24926   if (!arg2) {
24927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
24928     return 0;
24929   }
24930   {
24931     try {
24932       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
24933     } catch (std::out_of_range& e) {
24934       {
24935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24936       };
24937     } catch (std::exception& e) {
24938       {
24939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24940       };
24941     } catch (...) {
24942       {
24943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24944       };
24945     }
24946   }
24947   jresult = (void *)result;
24948   return jresult;
24949 }
24950
24951
24952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
24953   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24954   Dali::Actor arg2 ;
24955   Dali::Actor *argp2 ;
24956
24957   arg1 = (Dali::RenderTask *)jarg1;
24958   argp2 = (Dali::Actor *)jarg2;
24959   if (!argp2) {
24960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
24961     return ;
24962   }
24963   arg2 = *argp2;
24964   {
24965     try {
24966       (arg1)->SetSourceActor(arg2);
24967     } catch (std::out_of_range& e) {
24968       {
24969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24970       };
24971     } catch (std::exception& e) {
24972       {
24973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24974       };
24975     } catch (...) {
24976       {
24977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24978       };
24979     }
24980   }
24981 }
24982
24983
24984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
24985   void * jresult ;
24986   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
24987   Dali::Actor result;
24988
24989   arg1 = (Dali::RenderTask *)jarg1;
24990   {
24991     try {
24992       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
24993     } catch (std::out_of_range& e) {
24994       {
24995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24996       };
24997     } catch (std::exception& e) {
24998       {
24999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25000       };
25001     } catch (...) {
25002       {
25003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25004       };
25005     }
25006   }
25007   jresult = new Dali::Actor((const Dali::Actor &)result);
25008   return jresult;
25009 }
25010
25011
25012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
25013   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25014   bool arg2 ;
25015
25016   arg1 = (Dali::RenderTask *)jarg1;
25017   arg2 = jarg2 ? true : false;
25018   {
25019     try {
25020       (arg1)->SetExclusive(arg2);
25021     } catch (std::out_of_range& e) {
25022       {
25023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25024       };
25025     } catch (std::exception& e) {
25026       {
25027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25028       };
25029     } catch (...) {
25030       {
25031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25032       };
25033     }
25034   }
25035 }
25036
25037
25038 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
25039   unsigned int jresult ;
25040   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25041   bool result;
25042
25043   arg1 = (Dali::RenderTask *)jarg1;
25044   {
25045     try {
25046       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
25047     } catch (std::out_of_range& e) {
25048       {
25049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25050       };
25051     } catch (std::exception& e) {
25052       {
25053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25054       };
25055     } catch (...) {
25056       {
25057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25058       };
25059     }
25060   }
25061   jresult = result;
25062   return jresult;
25063 }
25064
25065
25066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
25067   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25068   bool arg2 ;
25069
25070   arg1 = (Dali::RenderTask *)jarg1;
25071   arg2 = jarg2 ? true : false;
25072   {
25073     try {
25074       (arg1)->SetInputEnabled(arg2);
25075     } catch (std::out_of_range& e) {
25076       {
25077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25078       };
25079     } catch (std::exception& e) {
25080       {
25081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25082       };
25083     } catch (...) {
25084       {
25085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25086       };
25087     }
25088   }
25089 }
25090
25091
25092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
25093   unsigned int jresult ;
25094   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25095   bool result;
25096
25097   arg1 = (Dali::RenderTask *)jarg1;
25098   {
25099     try {
25100       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
25101     } catch (std::out_of_range& e) {
25102       {
25103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25104       };
25105     } catch (std::exception& e) {
25106       {
25107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25108       };
25109     } catch (...) {
25110       {
25111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25112       };
25113     }
25114   }
25115   jresult = result;
25116   return jresult;
25117 }
25118
25119
25120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
25121   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25122   Dali::CameraActor arg2 ;
25123   Dali::CameraActor *argp2 ;
25124
25125   arg1 = (Dali::RenderTask *)jarg1;
25126   argp2 = (Dali::CameraActor *)jarg2;
25127   if (!argp2) {
25128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
25129     return ;
25130   }
25131   arg2 = *argp2;
25132   {
25133     try {
25134       (arg1)->SetCameraActor(arg2);
25135     } catch (std::out_of_range& e) {
25136       {
25137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25138       };
25139     } catch (std::exception& e) {
25140       {
25141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25142       };
25143     } catch (...) {
25144       {
25145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25146       };
25147     }
25148   }
25149 }
25150
25151
25152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
25153   void * jresult ;
25154   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25155   Dali::CameraActor result;
25156
25157   arg1 = (Dali::RenderTask *)jarg1;
25158   {
25159     try {
25160       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
25161     } catch (std::out_of_range& e) {
25162       {
25163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25164       };
25165     } catch (std::exception& e) {
25166       {
25167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25168       };
25169     } catch (...) {
25170       {
25171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25172       };
25173     }
25174   }
25175   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
25176   return jresult;
25177 }
25178
25179
25180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
25181   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25182   Dali::FrameBufferImage arg2 ;
25183   Dali::FrameBufferImage *argp2 ;
25184
25185   arg1 = (Dali::RenderTask *)jarg1;
25186   argp2 = (Dali::FrameBufferImage *)jarg2;
25187   if (!argp2) {
25188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
25189     return ;
25190   }
25191   arg2 = *argp2;
25192   {
25193     try {
25194       (arg1)->SetTargetFrameBuffer(arg2);
25195     } catch (std::out_of_range& e) {
25196       {
25197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25198       };
25199     } catch (std::exception& e) {
25200       {
25201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25202       };
25203     } catch (...) {
25204       {
25205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25206       };
25207     }
25208   }
25209 }
25210
25211
25212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
25213   void * jresult ;
25214   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25215   Dali::FrameBufferImage result;
25216
25217   arg1 = (Dali::RenderTask *)jarg1;
25218   {
25219     try {
25220       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
25221     } catch (std::out_of_range& e) {
25222       {
25223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25224       };
25225     } catch (std::exception& e) {
25226       {
25227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25228       };
25229     } catch (...) {
25230       {
25231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25232       };
25233     }
25234   }
25235   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
25236   return jresult;
25237 }
25238
25239
25240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
25241   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25242   Dali::FrameBuffer arg2 ;
25243   Dali::FrameBuffer *argp2 ;
25244
25245   arg1 = (Dali::RenderTask *)jarg1;
25246   argp2 = (Dali::FrameBuffer *)jarg2;
25247   if (!argp2) {
25248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
25249     return ;
25250   }
25251   arg2 = *argp2;
25252   {
25253     try {
25254       (arg1)->SetFrameBuffer(arg2);
25255     } catch (std::out_of_range& e) {
25256       {
25257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25258       };
25259     } catch (std::exception& e) {
25260       {
25261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25262       };
25263     } catch (...) {
25264       {
25265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25266       };
25267     }
25268   }
25269 }
25270
25271
25272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
25273   void * jresult ;
25274   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25275   Dali::FrameBuffer result;
25276
25277   arg1 = (Dali::RenderTask *)jarg1;
25278   {
25279     try {
25280       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
25281     } catch (std::out_of_range& e) {
25282       {
25283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25284       };
25285     } catch (std::exception& e) {
25286       {
25287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25288       };
25289     } catch (...) {
25290       {
25291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25292       };
25293     }
25294   }
25295   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
25296   return jresult;
25297 }
25298
25299
25300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
25301   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25302   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
25303
25304   arg1 = (Dali::RenderTask *)jarg1;
25305   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
25306   {
25307     try {
25308       (arg1)->SetScreenToFrameBufferFunction(arg2);
25309     } catch (std::out_of_range& e) {
25310       {
25311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25312       };
25313     } catch (std::exception& e) {
25314       {
25315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25316       };
25317     } catch (...) {
25318       {
25319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25320       };
25321     }
25322   }
25323 }
25324
25325
25326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
25327   void * jresult ;
25328   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25329   Dali::RenderTask::ScreenToFrameBufferFunction result;
25330
25331   arg1 = (Dali::RenderTask *)jarg1;
25332   {
25333     try {
25334       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
25335     } catch (std::out_of_range& e) {
25336       {
25337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25338       };
25339     } catch (std::exception& e) {
25340       {
25341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25342       };
25343     } catch (...) {
25344       {
25345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25346       };
25347     }
25348   }
25349   jresult = (void *)result;
25350   return jresult;
25351 }
25352
25353
25354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
25355   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25356   Dali::Actor arg2 ;
25357   Dali::Actor *argp2 ;
25358
25359   arg1 = (Dali::RenderTask *)jarg1;
25360   argp2 = (Dali::Actor *)jarg2;
25361   if (!argp2) {
25362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25363     return ;
25364   }
25365   arg2 = *argp2;
25366   {
25367     try {
25368       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
25369     } catch (std::out_of_range& e) {
25370       {
25371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25372       };
25373     } catch (std::exception& e) {
25374       {
25375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25376       };
25377     } catch (...) {
25378       {
25379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25380       };
25381     }
25382   }
25383 }
25384
25385
25386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
25387   void * jresult ;
25388   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25389   Dali::Actor result;
25390
25391   arg1 = (Dali::RenderTask *)jarg1;
25392   {
25393     try {
25394       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
25395     } catch (std::out_of_range& e) {
25396       {
25397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25398       };
25399     } catch (std::exception& e) {
25400       {
25401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25402       };
25403     } catch (...) {
25404       {
25405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25406       };
25407     }
25408   }
25409   jresult = new Dali::Actor((const Dali::Actor &)result);
25410   return jresult;
25411 }
25412
25413
25414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
25415   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25416   Dali::Vector2 arg2 ;
25417   Dali::Vector2 *argp2 ;
25418
25419   arg1 = (Dali::RenderTask *)jarg1;
25420   argp2 = (Dali::Vector2 *)jarg2;
25421   if (!argp2) {
25422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25423     return ;
25424   }
25425   arg2 = *argp2;
25426   {
25427     try {
25428       (arg1)->SetViewportPosition(arg2);
25429     } catch (std::out_of_range& e) {
25430       {
25431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25432       };
25433     } catch (std::exception& e) {
25434       {
25435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25436       };
25437     } catch (...) {
25438       {
25439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25440       };
25441     }
25442   }
25443 }
25444
25445
25446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
25447   void * jresult ;
25448   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25449   Dali::Vector2 result;
25450
25451   arg1 = (Dali::RenderTask *)jarg1;
25452   {
25453     try {
25454       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
25455     } catch (std::out_of_range& e) {
25456       {
25457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25458       };
25459     } catch (std::exception& e) {
25460       {
25461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25462       };
25463     } catch (...) {
25464       {
25465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25466       };
25467     }
25468   }
25469   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25470   return jresult;
25471 }
25472
25473
25474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
25475   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25476   Dali::Vector2 arg2 ;
25477   Dali::Vector2 *argp2 ;
25478
25479   arg1 = (Dali::RenderTask *)jarg1;
25480   argp2 = (Dali::Vector2 *)jarg2;
25481   if (!argp2) {
25482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
25483     return ;
25484   }
25485   arg2 = *argp2;
25486   {
25487     try {
25488       (arg1)->SetViewportSize(arg2);
25489     } catch (std::out_of_range& e) {
25490       {
25491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25492       };
25493     } catch (std::exception& e) {
25494       {
25495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25496       };
25497     } catch (...) {
25498       {
25499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25500       };
25501     }
25502   }
25503 }
25504
25505
25506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
25507   void * jresult ;
25508   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25509   Dali::Vector2 result;
25510
25511   arg1 = (Dali::RenderTask *)jarg1;
25512   {
25513     try {
25514       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
25515     } catch (std::out_of_range& e) {
25516       {
25517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25518       };
25519     } catch (std::exception& e) {
25520       {
25521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25522       };
25523     } catch (...) {
25524       {
25525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25526       };
25527     }
25528   }
25529   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
25530   return jresult;
25531 }
25532
25533
25534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
25535   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25536   Dali::Viewport arg2 ;
25537   Dali::Viewport *argp2 ;
25538
25539   arg1 = (Dali::RenderTask *)jarg1;
25540   argp2 = (Dali::Viewport *)jarg2;
25541   if (!argp2) {
25542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
25543     return ;
25544   }
25545   arg2 = *argp2;
25546   {
25547     try {
25548       (arg1)->SetViewport(arg2);
25549     } catch (std::out_of_range& e) {
25550       {
25551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25552       };
25553     } catch (std::exception& e) {
25554       {
25555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25556       };
25557     } catch (...) {
25558       {
25559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25560       };
25561     }
25562   }
25563 }
25564
25565
25566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
25567   void * jresult ;
25568   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25569   Dali::Viewport result;
25570
25571   arg1 = (Dali::RenderTask *)jarg1;
25572   {
25573     try {
25574       result = ((Dali::RenderTask const *)arg1)->GetViewport();
25575     } catch (std::out_of_range& e) {
25576       {
25577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25578       };
25579     } catch (std::exception& e) {
25580       {
25581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25582       };
25583     } catch (...) {
25584       {
25585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25586       };
25587     }
25588   }
25589   jresult = new Dali::Viewport((const Dali::Viewport &)result);
25590   return jresult;
25591 }
25592
25593
25594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
25595   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25596   Dali::Vector4 *arg2 = 0 ;
25597
25598   arg1 = (Dali::RenderTask *)jarg1;
25599   arg2 = (Dali::Vector4 *)jarg2;
25600   if (!arg2) {
25601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
25602     return ;
25603   }
25604   {
25605     try {
25606       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
25607     } catch (std::out_of_range& e) {
25608       {
25609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25610       };
25611     } catch (std::exception& e) {
25612       {
25613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25614       };
25615     } catch (...) {
25616       {
25617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25618       };
25619     }
25620   }
25621 }
25622
25623
25624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
25625   void * jresult ;
25626   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25627   Dali::Vector4 result;
25628
25629   arg1 = (Dali::RenderTask *)jarg1;
25630   {
25631     try {
25632       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
25633     } catch (std::out_of_range& e) {
25634       {
25635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25636       };
25637     } catch (std::exception& e) {
25638       {
25639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25640       };
25641     } catch (...) {
25642       {
25643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25644       };
25645     }
25646   }
25647   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
25648   return jresult;
25649 }
25650
25651
25652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
25653   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25654   bool arg2 ;
25655
25656   arg1 = (Dali::RenderTask *)jarg1;
25657   arg2 = jarg2 ? true : false;
25658   {
25659     try {
25660       (arg1)->SetClearEnabled(arg2);
25661     } catch (std::out_of_range& e) {
25662       {
25663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25664       };
25665     } catch (std::exception& e) {
25666       {
25667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25668       };
25669     } catch (...) {
25670       {
25671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25672       };
25673     }
25674   }
25675 }
25676
25677
25678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
25679   unsigned int jresult ;
25680   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25681   bool result;
25682
25683   arg1 = (Dali::RenderTask *)jarg1;
25684   {
25685     try {
25686       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
25687     } catch (std::out_of_range& e) {
25688       {
25689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25690       };
25691     } catch (std::exception& e) {
25692       {
25693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25694       };
25695     } catch (...) {
25696       {
25697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25698       };
25699     }
25700   }
25701   jresult = result;
25702   return jresult;
25703 }
25704
25705
25706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
25707   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25708   bool arg2 ;
25709
25710   arg1 = (Dali::RenderTask *)jarg1;
25711   arg2 = jarg2 ? true : false;
25712   {
25713     try {
25714       (arg1)->SetCullMode(arg2);
25715     } catch (std::out_of_range& e) {
25716       {
25717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25718       };
25719     } catch (std::exception& e) {
25720       {
25721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25722       };
25723     } catch (...) {
25724       {
25725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25726       };
25727     }
25728   }
25729 }
25730
25731
25732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
25733   unsigned int jresult ;
25734   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25735   bool result;
25736
25737   arg1 = (Dali::RenderTask *)jarg1;
25738   {
25739     try {
25740       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
25741     } catch (std::out_of_range& e) {
25742       {
25743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25744       };
25745     } catch (std::exception& e) {
25746       {
25747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25748       };
25749     } catch (...) {
25750       {
25751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25752       };
25753     }
25754   }
25755   jresult = result;
25756   return jresult;
25757 }
25758
25759
25760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
25761   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25762   unsigned int arg2 ;
25763
25764   arg1 = (Dali::RenderTask *)jarg1;
25765   arg2 = (unsigned int)jarg2;
25766   {
25767     try {
25768       (arg1)->SetRefreshRate(arg2);
25769     } catch (std::out_of_range& e) {
25770       {
25771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25772       };
25773     } catch (std::exception& e) {
25774       {
25775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25776       };
25777     } catch (...) {
25778       {
25779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25780       };
25781     }
25782   }
25783 }
25784
25785
25786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
25787   unsigned int jresult ;
25788   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25789   unsigned int result;
25790
25791   arg1 = (Dali::RenderTask *)jarg1;
25792   {
25793     try {
25794       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
25795     } catch (std::out_of_range& e) {
25796       {
25797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25798       };
25799     } catch (std::exception& e) {
25800       {
25801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25802       };
25803     } catch (...) {
25804       {
25805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25806       };
25807     }
25808   }
25809   jresult = result;
25810   return jresult;
25811 }
25812
25813
25814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
25815   unsigned int jresult ;
25816   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25817   Dali::Vector3 *arg2 = 0 ;
25818   float *arg3 = 0 ;
25819   float *arg4 = 0 ;
25820   bool result;
25821
25822   arg1 = (Dali::RenderTask *)jarg1;
25823   arg2 = (Dali::Vector3 *)jarg2;
25824   if (!arg2) {
25825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
25826     return 0;
25827   }
25828   arg3 = (float *)jarg3;
25829   arg4 = (float *)jarg4;
25830   {
25831     try {
25832       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
25833     } catch (std::out_of_range& e) {
25834       {
25835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25836       };
25837     } catch (std::exception& e) {
25838       {
25839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25840       };
25841     } catch (...) {
25842       {
25843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25844       };
25845     }
25846   }
25847   jresult = result;
25848   return jresult;
25849 }
25850
25851
25852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
25853   unsigned int jresult ;
25854   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25855   Dali::Actor arg2 ;
25856   float arg3 ;
25857   float arg4 ;
25858   float *arg5 = 0 ;
25859   float *arg6 = 0 ;
25860   Dali::Actor *argp2 ;
25861   bool result;
25862
25863   arg1 = (Dali::RenderTask *)jarg1;
25864   argp2 = (Dali::Actor *)jarg2;
25865   if (!argp2) {
25866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
25867     return 0;
25868   }
25869   arg2 = *argp2;
25870   arg3 = (float)jarg3;
25871   arg4 = (float)jarg4;
25872   arg5 = (float *)jarg5;
25873   arg6 = (float *)jarg6;
25874   {
25875     try {
25876       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
25877     } catch (std::out_of_range& e) {
25878       {
25879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25880       };
25881     } catch (std::exception& e) {
25882       {
25883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25884       };
25885     } catch (...) {
25886       {
25887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25888       };
25889     }
25890   }
25891   jresult = result;
25892   return jresult;
25893 }
25894
25895
25896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
25897   void * jresult ;
25898   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
25899   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
25900
25901   arg1 = (Dali::RenderTask *)jarg1;
25902   {
25903     try {
25904       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
25905     } catch (std::out_of_range& e) {
25906       {
25907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25908       };
25909     } catch (std::exception& e) {
25910       {
25911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25912       };
25913     } catch (...) {
25914       {
25915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25916       };
25917     }
25918   }
25919   jresult = (void *)result;
25920   return jresult;
25921 }
25922
25923
25924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
25925   void * jresult ;
25926   int arg1 ;
25927   Dali::TouchPoint::State arg2 ;
25928   float arg3 ;
25929   float arg4 ;
25930   Dali::TouchPoint *result = 0 ;
25931
25932   arg1 = (int)jarg1;
25933   arg2 = (Dali::TouchPoint::State)jarg2;
25934   arg3 = (float)jarg3;
25935   arg4 = (float)jarg4;
25936   {
25937     try {
25938       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
25939     } catch (std::out_of_range& e) {
25940       {
25941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25942       };
25943     } catch (std::exception& e) {
25944       {
25945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25946       };
25947     } catch (...) {
25948       {
25949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25950       };
25951     }
25952   }
25953   jresult = (void *)result;
25954   return jresult;
25955 }
25956
25957
25958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
25959   void * jresult ;
25960   int arg1 ;
25961   Dali::TouchPoint::State arg2 ;
25962   float arg3 ;
25963   float arg4 ;
25964   float arg5 ;
25965   float arg6 ;
25966   Dali::TouchPoint *result = 0 ;
25967
25968   arg1 = (int)jarg1;
25969   arg2 = (Dali::TouchPoint::State)jarg2;
25970   arg3 = (float)jarg3;
25971   arg4 = (float)jarg4;
25972   arg5 = (float)jarg5;
25973   arg6 = (float)jarg6;
25974   {
25975     try {
25976       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
25977     } catch (std::out_of_range& e) {
25978       {
25979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25980       };
25981     } catch (std::exception& e) {
25982       {
25983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25984       };
25985     } catch (...) {
25986       {
25987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25988       };
25989     }
25990   }
25991   jresult = (void *)result;
25992   return jresult;
25993 }
25994
25995
25996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
25997   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
25998
25999   arg1 = (Dali::TouchPoint *)jarg1;
26000   {
26001     try {
26002       delete arg1;
26003     } catch (std::out_of_range& e) {
26004       {
26005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26006       };
26007     } catch (std::exception& e) {
26008       {
26009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26010       };
26011     } catch (...) {
26012       {
26013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26014       };
26015     }
26016   }
26017 }
26018
26019
26020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
26021   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26022   int arg2 ;
26023
26024   arg1 = (Dali::TouchPoint *)jarg1;
26025   arg2 = (int)jarg2;
26026   if (arg1) (arg1)->deviceId = arg2;
26027 }
26028
26029
26030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
26031   int jresult ;
26032   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26033   int result;
26034
26035   arg1 = (Dali::TouchPoint *)jarg1;
26036   result = (int) ((arg1)->deviceId);
26037   jresult = result;
26038   return jresult;
26039 }
26040
26041
26042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
26043   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26044   Dali::TouchPoint::State arg2 ;
26045
26046   arg1 = (Dali::TouchPoint *)jarg1;
26047   arg2 = (Dali::TouchPoint::State)jarg2;
26048   if (arg1) (arg1)->state = arg2;
26049 }
26050
26051
26052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
26053   int jresult ;
26054   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26055   Dali::TouchPoint::State result;
26056
26057   arg1 = (Dali::TouchPoint *)jarg1;
26058   result = (Dali::TouchPoint::State) ((arg1)->state);
26059   jresult = (int)result;
26060   return jresult;
26061 }
26062
26063
26064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
26065   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26066   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
26067
26068   arg1 = (Dali::TouchPoint *)jarg1;
26069   arg2 = (Dali::Actor *)jarg2;
26070   if (arg1) (arg1)->hitActor = *arg2;
26071 }
26072
26073
26074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
26075   void * jresult ;
26076   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26077   Dali::Actor *result = 0 ;
26078
26079   arg1 = (Dali::TouchPoint *)jarg1;
26080   result = (Dali::Actor *)& ((arg1)->hitActor);
26081   jresult = (void *)result;
26082   return jresult;
26083 }
26084
26085
26086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
26087   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26088   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26089
26090   arg1 = (Dali::TouchPoint *)jarg1;
26091   arg2 = (Dali::Vector2 *)jarg2;
26092   if (arg1) (arg1)->local = *arg2;
26093 }
26094
26095
26096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
26097   void * jresult ;
26098   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26099   Dali::Vector2 *result = 0 ;
26100
26101   arg1 = (Dali::TouchPoint *)jarg1;
26102   result = (Dali::Vector2 *)& ((arg1)->local);
26103   jresult = (void *)result;
26104   return jresult;
26105 }
26106
26107
26108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
26109   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26110   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
26111
26112   arg1 = (Dali::TouchPoint *)jarg1;
26113   arg2 = (Dali::Vector2 *)jarg2;
26114   if (arg1) (arg1)->screen = *arg2;
26115 }
26116
26117
26118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
26119   void * jresult ;
26120   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
26121   Dali::Vector2 *result = 0 ;
26122
26123   arg1 = (Dali::TouchPoint *)jarg1;
26124   result = (Dali::Vector2 *)& ((arg1)->screen);
26125   jresult = (void *)result;
26126   return jresult;
26127 }
26128
26129
26130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
26131   void * jresult ;
26132   Dali::TouchData *result = 0 ;
26133
26134   {
26135     try {
26136       result = (Dali::TouchData *)new Dali::TouchData();
26137     } catch (std::out_of_range& e) {
26138       {
26139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26140       };
26141     } catch (std::exception& e) {
26142       {
26143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26144       };
26145     } catch (...) {
26146       {
26147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26148       };
26149     }
26150   }
26151   jresult = (void *)result;
26152   return jresult;
26153 }
26154
26155
26156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
26157   void * jresult ;
26158   Dali::TouchData *arg1 = 0 ;
26159   Dali::TouchData *result = 0 ;
26160
26161   arg1 = (Dali::TouchData *)jarg1;
26162   if (!arg1) {
26163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26164     return 0;
26165   }
26166   {
26167     try {
26168       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
26169     } catch (std::out_of_range& e) {
26170       {
26171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26172       };
26173     } catch (std::exception& e) {
26174       {
26175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26176       };
26177     } catch (...) {
26178       {
26179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26180       };
26181     }
26182   }
26183   jresult = (void *)result;
26184   return jresult;
26185 }
26186
26187
26188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
26189   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26190
26191   arg1 = (Dali::TouchData *)jarg1;
26192   {
26193     try {
26194       delete arg1;
26195     } catch (std::out_of_range& e) {
26196       {
26197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26198       };
26199     } catch (std::exception& e) {
26200       {
26201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26202       };
26203     } catch (...) {
26204       {
26205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26206       };
26207     }
26208   }
26209 }
26210
26211
26212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
26213   void * jresult ;
26214   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26215   Dali::TouchData *arg2 = 0 ;
26216   Dali::TouchData *result = 0 ;
26217
26218   arg1 = (Dali::TouchData *)jarg1;
26219   arg2 = (Dali::TouchData *)jarg2;
26220   if (!arg2) {
26221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
26222     return 0;
26223   }
26224   {
26225     try {
26226       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
26227     } catch (std::out_of_range& e) {
26228       {
26229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26230       };
26231     } catch (std::exception& e) {
26232       {
26233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26234       };
26235     } catch (...) {
26236       {
26237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26238       };
26239     }
26240   }
26241   jresult = (void *)result;
26242   return jresult;
26243 }
26244
26245
26246 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
26247   unsigned long jresult ;
26248   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26249   unsigned long result;
26250
26251   arg1 = (Dali::TouchData *)jarg1;
26252   {
26253     try {
26254       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
26255     } catch (std::out_of_range& e) {
26256       {
26257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26258       };
26259     } catch (std::exception& e) {
26260       {
26261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26262       };
26263     } catch (...) {
26264       {
26265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26266       };
26267     }
26268   }
26269   jresult = (unsigned long)result;
26270   return jresult;
26271 }
26272
26273
26274 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
26275   unsigned long jresult ;
26276   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26277   std::size_t result;
26278
26279   arg1 = (Dali::TouchData *)jarg1;
26280   {
26281     try {
26282       result = ((Dali::TouchData const *)arg1)->GetPointCount();
26283     } catch (std::out_of_range& e) {
26284       {
26285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26286       };
26287     } catch (std::exception& e) {
26288       {
26289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26290       };
26291     } catch (...) {
26292       {
26293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26294       };
26295     }
26296   }
26297   jresult = (unsigned long)result;
26298   return jresult;
26299 }
26300
26301
26302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
26303   int jresult ;
26304   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26305   std::size_t arg2 ;
26306   int32_t result;
26307
26308   arg1 = (Dali::TouchData *)jarg1;
26309   arg2 = (std::size_t)jarg2;
26310   {
26311     try {
26312       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
26313     } catch (std::out_of_range& e) {
26314       {
26315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26316       };
26317     } catch (std::exception& e) {
26318       {
26319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26320       };
26321     } catch (...) {
26322       {
26323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26324       };
26325     }
26326   }
26327   jresult = result;
26328   return jresult;
26329 }
26330
26331
26332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
26333   int jresult ;
26334   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26335   std::size_t arg2 ;
26336   Dali::PointState::Type result;
26337
26338   arg1 = (Dali::TouchData *)jarg1;
26339   arg2 = (std::size_t)jarg2;
26340   {
26341     try {
26342       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
26343     } catch (std::out_of_range& e) {
26344       {
26345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26346       };
26347     } catch (std::exception& e) {
26348       {
26349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26350       };
26351     } catch (...) {
26352       {
26353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26354       };
26355     }
26356   }
26357   jresult = (int)result;
26358   return jresult;
26359 }
26360
26361
26362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
26363   void * jresult ;
26364   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26365   std::size_t arg2 ;
26366   Dali::Actor result;
26367
26368   arg1 = (Dali::TouchData *)jarg1;
26369   arg2 = (std::size_t)jarg2;
26370   {
26371     try {
26372       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
26373     } catch (std::out_of_range& e) {
26374       {
26375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26376       };
26377     } catch (std::exception& e) {
26378       {
26379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26380       };
26381     } catch (...) {
26382       {
26383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26384       };
26385     }
26386   }
26387   jresult = new Dali::Actor((const Dali::Actor &)result);
26388   return jresult;
26389 }
26390
26391
26392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
26393   void * jresult ;
26394   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26395   std::size_t arg2 ;
26396   Dali::Vector2 *result = 0 ;
26397
26398   arg1 = (Dali::TouchData *)jarg1;
26399   arg2 = (std::size_t)jarg2;
26400   {
26401     try {
26402       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
26403     } catch (std::out_of_range& e) {
26404       {
26405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26406       };
26407     } catch (std::exception& e) {
26408       {
26409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26410       };
26411     } catch (...) {
26412       {
26413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26414       };
26415     }
26416   }
26417   jresult = (void *)result;
26418   return jresult;
26419 }
26420
26421
26422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
26423   void * jresult ;
26424   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26425   std::size_t arg2 ;
26426   Dali::Vector2 *result = 0 ;
26427
26428   arg1 = (Dali::TouchData *)jarg1;
26429   arg2 = (std::size_t)jarg2;
26430   {
26431     try {
26432       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
26433     } catch (std::out_of_range& e) {
26434       {
26435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26436       };
26437     } catch (std::exception& e) {
26438       {
26439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26440       };
26441     } catch (...) {
26442       {
26443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26444       };
26445     }
26446   }
26447   jresult = (void *)result;
26448   return jresult;
26449 }
26450
26451
26452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
26453   float jresult ;
26454   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26455   std::size_t arg2 ;
26456   float result;
26457
26458   arg1 = (Dali::TouchData *)jarg1;
26459   arg2 = (std::size_t)jarg2;
26460   {
26461     try {
26462       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
26463     } catch (std::out_of_range& e) {
26464       {
26465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26466       };
26467     } catch (std::exception& e) {
26468       {
26469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26470       };
26471     } catch (...) {
26472       {
26473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26474       };
26475     }
26476   }
26477   jresult = result;
26478   return jresult;
26479 }
26480
26481
26482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
26483   void * jresult ;
26484   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26485   std::size_t arg2 ;
26486   Dali::Vector2 *result = 0 ;
26487
26488   arg1 = (Dali::TouchData *)jarg1;
26489   arg2 = (std::size_t)jarg2;
26490   {
26491     try {
26492       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
26493     } catch (std::out_of_range& e) {
26494       {
26495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26496       };
26497     } catch (std::exception& e) {
26498       {
26499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26500       };
26501     } catch (...) {
26502       {
26503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26504       };
26505     }
26506   }
26507   jresult = (void *)result;
26508   return jresult;
26509 }
26510
26511
26512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
26513   float jresult ;
26514   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26515   std::size_t arg2 ;
26516   float result;
26517
26518   arg1 = (Dali::TouchData *)jarg1;
26519   arg2 = (std::size_t)jarg2;
26520   {
26521     try {
26522       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
26523     } catch (std::out_of_range& e) {
26524       {
26525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26526       };
26527     } catch (std::exception& e) {
26528       {
26529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26530       };
26531     } catch (...) {
26532       {
26533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26534       };
26535     }
26536   }
26537   jresult = result;
26538   return jresult;
26539 }
26540
26541
26542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
26543   void * jresult ;
26544   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
26545   std::size_t arg2 ;
26546   Dali::Degree result;
26547
26548   arg1 = (Dali::TouchData *)jarg1;
26549   arg2 = (std::size_t)jarg2;
26550   {
26551     try {
26552       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
26553     } catch (std::out_of_range& e) {
26554       {
26555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26556       };
26557     } catch (std::exception& e) {
26558       {
26559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26560       };
26561     } catch (...) {
26562       {
26563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26564       };
26565     }
26566   }
26567   jresult = new Dali::Degree((const Dali::Degree &)result);
26568   return jresult;
26569 }
26570
26571
26572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
26573   void * jresult ;
26574   Dali::GestureDetector *result = 0 ;
26575
26576   {
26577     try {
26578       result = (Dali::GestureDetector *)new Dali::GestureDetector();
26579     } catch (std::out_of_range& e) {
26580       {
26581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26582       };
26583     } catch (std::exception& e) {
26584       {
26585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26586       };
26587     } catch (...) {
26588       {
26589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26590       };
26591     }
26592   }
26593   jresult = (void *)result;
26594   return jresult;
26595 }
26596
26597
26598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
26599   void * jresult ;
26600   Dali::BaseHandle arg1 ;
26601   Dali::BaseHandle *argp1 ;
26602   Dali::GestureDetector result;
26603
26604   argp1 = (Dali::BaseHandle *)jarg1;
26605   if (!argp1) {
26606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26607     return 0;
26608   }
26609   arg1 = *argp1;
26610   {
26611     try {
26612       result = Dali::GestureDetector::DownCast(arg1);
26613     } catch (std::out_of_range& e) {
26614       {
26615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26616       };
26617     } catch (std::exception& e) {
26618       {
26619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26620       };
26621     } catch (...) {
26622       {
26623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26624       };
26625     }
26626   }
26627   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
26628   return jresult;
26629 }
26630
26631
26632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
26633   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26634
26635   arg1 = (Dali::GestureDetector *)jarg1;
26636   {
26637     try {
26638       delete arg1;
26639     } catch (std::out_of_range& e) {
26640       {
26641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26642       };
26643     } catch (std::exception& e) {
26644       {
26645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26646       };
26647     } catch (...) {
26648       {
26649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26650       };
26651     }
26652   }
26653 }
26654
26655
26656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
26657   void * jresult ;
26658   Dali::GestureDetector *arg1 = 0 ;
26659   Dali::GestureDetector *result = 0 ;
26660
26661   arg1 = (Dali::GestureDetector *)jarg1;
26662   if (!arg1) {
26663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26664     return 0;
26665   }
26666   {
26667     try {
26668       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
26669     } catch (std::out_of_range& e) {
26670       {
26671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26672       };
26673     } catch (std::exception& e) {
26674       {
26675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26676       };
26677     } catch (...) {
26678       {
26679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26680       };
26681     }
26682   }
26683   jresult = (void *)result;
26684   return jresult;
26685 }
26686
26687
26688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
26689   void * jresult ;
26690   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26691   Dali::GestureDetector *arg2 = 0 ;
26692   Dali::GestureDetector *result = 0 ;
26693
26694   arg1 = (Dali::GestureDetector *)jarg1;
26695   arg2 = (Dali::GestureDetector *)jarg2;
26696   if (!arg2) {
26697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
26698     return 0;
26699   }
26700   {
26701     try {
26702       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
26703     } catch (std::out_of_range& e) {
26704       {
26705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26706       };
26707     } catch (std::exception& e) {
26708       {
26709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26710       };
26711     } catch (...) {
26712       {
26713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26714       };
26715     }
26716   }
26717   jresult = (void *)result;
26718   return jresult;
26719 }
26720
26721
26722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
26723   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26724   Dali::Actor arg2 ;
26725   Dali::Actor *argp2 ;
26726
26727   arg1 = (Dali::GestureDetector *)jarg1;
26728   argp2 = (Dali::Actor *)jarg2;
26729   if (!argp2) {
26730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26731     return ;
26732   }
26733   arg2 = *argp2;
26734   {
26735     try {
26736       (arg1)->Attach(arg2);
26737     } catch (std::out_of_range& e) {
26738       {
26739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26740       };
26741     } catch (std::exception& e) {
26742       {
26743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26744       };
26745     } catch (...) {
26746       {
26747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26748       };
26749     }
26750   }
26751 }
26752
26753
26754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
26755   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26756   Dali::Actor arg2 ;
26757   Dali::Actor *argp2 ;
26758
26759   arg1 = (Dali::GestureDetector *)jarg1;
26760   argp2 = (Dali::Actor *)jarg2;
26761   if (!argp2) {
26762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
26763     return ;
26764   }
26765   arg2 = *argp2;
26766   {
26767     try {
26768       (arg1)->Detach(arg2);
26769     } catch (std::out_of_range& e) {
26770       {
26771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26772       };
26773     } catch (std::exception& e) {
26774       {
26775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26776       };
26777     } catch (...) {
26778       {
26779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26780       };
26781     }
26782   }
26783 }
26784
26785
26786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
26787   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26788
26789   arg1 = (Dali::GestureDetector *)jarg1;
26790   {
26791     try {
26792       (arg1)->DetachAll();
26793     } catch (std::out_of_range& e) {
26794       {
26795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26796       };
26797     } catch (std::exception& e) {
26798       {
26799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26800       };
26801     } catch (...) {
26802       {
26803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26804       };
26805     }
26806   }
26807 }
26808
26809
26810 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
26811   unsigned long jresult ;
26812   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26813   size_t result;
26814
26815   arg1 = (Dali::GestureDetector *)jarg1;
26816   {
26817     try {
26818       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
26819     } catch (std::out_of_range& e) {
26820       {
26821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26822       };
26823     } catch (std::exception& e) {
26824       {
26825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26826       };
26827     } catch (...) {
26828       {
26829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26830       };
26831     }
26832   }
26833   jresult = (unsigned long)result;
26834   return jresult;
26835 }
26836
26837
26838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
26839   void * jresult ;
26840   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
26841   size_t arg2 ;
26842   Dali::Actor result;
26843
26844   arg1 = (Dali::GestureDetector *)jarg1;
26845   arg2 = (size_t)jarg2;
26846   {
26847     try {
26848       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
26849     } catch (std::out_of_range& e) {
26850       {
26851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26852       };
26853     } catch (std::exception& e) {
26854       {
26855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26856       };
26857     } catch (...) {
26858       {
26859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26860       };
26861     }
26862   }
26863   jresult = new Dali::Actor((const Dali::Actor &)result);
26864   return jresult;
26865 }
26866
26867
26868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
26869   void * jresult ;
26870   Dali::Gesture *arg1 = 0 ;
26871   Dali::Gesture *result = 0 ;
26872
26873   arg1 = (Dali::Gesture *)jarg1;
26874   if (!arg1) {
26875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26876     return 0;
26877   }
26878   {
26879     try {
26880       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
26881     } catch (std::out_of_range& e) {
26882       {
26883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26884       };
26885     } catch (std::exception& e) {
26886       {
26887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26888       };
26889     } catch (...) {
26890       {
26891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26892       };
26893     }
26894   }
26895   jresult = (void *)result;
26896   return jresult;
26897 }
26898
26899
26900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
26901   void * jresult ;
26902   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26903   Dali::Gesture *arg2 = 0 ;
26904   Dali::Gesture *result = 0 ;
26905
26906   arg1 = (Dali::Gesture *)jarg1;
26907   arg2 = (Dali::Gesture *)jarg2;
26908   if (!arg2) {
26909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
26910     return 0;
26911   }
26912   {
26913     try {
26914       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
26915     } catch (std::out_of_range& e) {
26916       {
26917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26918       };
26919     } catch (std::exception& e) {
26920       {
26921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26922       };
26923     } catch (...) {
26924       {
26925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26926       };
26927     }
26928   }
26929   jresult = (void *)result;
26930   return jresult;
26931 }
26932
26933
26934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
26935   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26936
26937   arg1 = (Dali::Gesture *)jarg1;
26938   {
26939     try {
26940       delete arg1;
26941     } catch (std::out_of_range& e) {
26942       {
26943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26944       };
26945     } catch (std::exception& e) {
26946       {
26947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26948       };
26949     } catch (...) {
26950       {
26951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26952       };
26953     }
26954   }
26955 }
26956
26957
26958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
26959   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26960   Dali::Gesture::Type arg2 ;
26961
26962   arg1 = (Dali::Gesture *)jarg1;
26963   arg2 = (Dali::Gesture::Type)jarg2;
26964   if (arg1) (arg1)->type = arg2;
26965 }
26966
26967
26968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
26969   int jresult ;
26970   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26971   Dali::Gesture::Type result;
26972
26973   arg1 = (Dali::Gesture *)jarg1;
26974   result = (Dali::Gesture::Type) ((arg1)->type);
26975   jresult = (int)result;
26976   return jresult;
26977 }
26978
26979
26980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
26981   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26982   Dali::Gesture::State arg2 ;
26983
26984   arg1 = (Dali::Gesture *)jarg1;
26985   arg2 = (Dali::Gesture::State)jarg2;
26986   if (arg1) (arg1)->state = arg2;
26987 }
26988
26989
26990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
26991   int jresult ;
26992   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
26993   Dali::Gesture::State result;
26994
26995   arg1 = (Dali::Gesture *)jarg1;
26996   result = (Dali::Gesture::State) ((arg1)->state);
26997   jresult = (int)result;
26998   return jresult;
26999 }
27000
27001
27002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
27003   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27004   unsigned int arg2 ;
27005
27006   arg1 = (Dali::Gesture *)jarg1;
27007   arg2 = (unsigned int)jarg2;
27008   if (arg1) (arg1)->time = arg2;
27009 }
27010
27011
27012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
27013   unsigned int jresult ;
27014   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
27015   unsigned int result;
27016
27017   arg1 = (Dali::Gesture *)jarg1;
27018   result = (unsigned int) ((arg1)->time);
27019   jresult = result;
27020   return jresult;
27021 }
27022
27023
27024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
27025   void * jresult ;
27026   Dali::HoverEvent *result = 0 ;
27027
27028   {
27029     try {
27030       result = (Dali::HoverEvent *)new Dali::HoverEvent();
27031     } catch (std::out_of_range& e) {
27032       {
27033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27034       };
27035     } catch (std::exception& e) {
27036       {
27037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27038       };
27039     } catch (...) {
27040       {
27041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27042       };
27043     }
27044   }
27045   jresult = (void *)result;
27046   return jresult;
27047 }
27048
27049
27050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
27051   void * jresult ;
27052   unsigned long arg1 ;
27053   Dali::HoverEvent *result = 0 ;
27054
27055   arg1 = (unsigned long)jarg1;
27056   {
27057     try {
27058       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
27059     } catch (std::out_of_range& e) {
27060       {
27061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27062       };
27063     } catch (std::exception& e) {
27064       {
27065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27066       };
27067     } catch (...) {
27068       {
27069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27070       };
27071     }
27072   }
27073   jresult = (void *)result;
27074   return jresult;
27075 }
27076
27077
27078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
27079   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27080
27081   arg1 = (Dali::HoverEvent *)jarg1;
27082   {
27083     try {
27084       delete arg1;
27085     } catch (std::out_of_range& e) {
27086       {
27087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27088       };
27089     } catch (std::exception& e) {
27090       {
27091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27092       };
27093     } catch (...) {
27094       {
27095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27096       };
27097     }
27098   }
27099 }
27100
27101
27102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
27103   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27104   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
27105
27106   arg1 = (Dali::HoverEvent *)jarg1;
27107   arg2 = (Dali::TouchPointContainer *)jarg2;
27108   if (arg1) (arg1)->points = *arg2;
27109 }
27110
27111
27112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
27113   void * jresult ;
27114   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27115   Dali::TouchPointContainer *result = 0 ;
27116
27117   arg1 = (Dali::HoverEvent *)jarg1;
27118   result = (Dali::TouchPointContainer *)& ((arg1)->points);
27119   jresult = (void *)result;
27120   return jresult;
27121 }
27122
27123
27124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
27125   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27126   unsigned long arg2 ;
27127
27128   arg1 = (Dali::HoverEvent *)jarg1;
27129   arg2 = (unsigned long)jarg2;
27130   if (arg1) (arg1)->time = arg2;
27131 }
27132
27133
27134 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
27135   unsigned long jresult ;
27136   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27137   unsigned long result;
27138
27139   arg1 = (Dali::HoverEvent *)jarg1;
27140   result = (unsigned long) ((arg1)->time);
27141   jresult = (unsigned long)result;
27142   return jresult;
27143 }
27144
27145
27146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
27147   unsigned int jresult ;
27148   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27149   unsigned int result;
27150
27151   arg1 = (Dali::HoverEvent *)jarg1;
27152   {
27153     try {
27154       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
27155     } catch (std::out_of_range& e) {
27156       {
27157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27158       };
27159     } catch (std::exception& e) {
27160       {
27161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27162       };
27163     } catch (...) {
27164       {
27165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27166       };
27167     }
27168   }
27169   jresult = result;
27170   return jresult;
27171 }
27172
27173
27174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
27175   void * jresult ;
27176   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
27177   unsigned int arg2 ;
27178   Dali::TouchPoint *result = 0 ;
27179
27180   arg1 = (Dali::HoverEvent *)jarg1;
27181   arg2 = (unsigned int)jarg2;
27182   {
27183     try {
27184       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
27185     } catch (std::out_of_range& e) {
27186       {
27187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27188       };
27189     } catch (std::exception& e) {
27190       {
27191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27192       };
27193     } catch (...) {
27194       {
27195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27196       };
27197     }
27198   }
27199   jresult = (void *)result;
27200   return jresult;
27201 }
27202
27203
27204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
27205   void * jresult ;
27206   Dali::KeyEvent *result = 0 ;
27207
27208   {
27209     try {
27210       result = (Dali::KeyEvent *)new Dali::KeyEvent();
27211     } catch (std::out_of_range& e) {
27212       {
27213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27214       };
27215     } catch (std::exception& e) {
27216       {
27217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27218       };
27219     } catch (...) {
27220       {
27221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27222       };
27223     }
27224   }
27225   jresult = (void *)result;
27226   return jresult;
27227 }
27228
27229
27230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
27231   void * jresult ;
27232   std::string *arg1 = 0 ;
27233   std::string *arg2 = 0 ;
27234   int arg3 ;
27235   int arg4 ;
27236   unsigned long arg5 ;
27237   Dali::KeyEvent::State *arg6 = 0 ;
27238   Dali::KeyEvent::State temp6 ;
27239   Dali::KeyEvent *result = 0 ;
27240
27241   if (!jarg1) {
27242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27243     return 0;
27244   }
27245   std::string arg1_str(jarg1);
27246   arg1 = &arg1_str;
27247   if (!jarg2) {
27248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27249     return 0;
27250   }
27251   std::string arg2_str(jarg2);
27252   arg2 = &arg2_str;
27253   arg3 = (int)jarg3;
27254   arg4 = (int)jarg4;
27255   arg5 = (unsigned long)jarg5;
27256   temp6 = (Dali::KeyEvent::State)jarg6;
27257   arg6 = &temp6;
27258   {
27259     try {
27260       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
27261     } catch (std::out_of_range& e) {
27262       {
27263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27264       };
27265     } catch (std::exception& e) {
27266       {
27267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27268       };
27269     } catch (...) {
27270       {
27271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27272       };
27273     }
27274   }
27275   jresult = (void *)result;
27276
27277   //argout typemap for const std::string&
27278
27279
27280   //argout typemap for const std::string&
27281
27282   return jresult;
27283 }
27284
27285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
27286   void * jresult ;
27287   Dali::KeyEvent *arg1 = 0 ;
27288   Dali::KeyEvent *result = 0 ;
27289
27290   arg1 = (Dali::KeyEvent *)jarg1;
27291   if (!arg1) {
27292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27293     return 0;
27294   }
27295   {
27296     try {
27297       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
27298     } catch (std::out_of_range& e) {
27299       {
27300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27301       };
27302     } catch (std::exception& e) {
27303       {
27304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27305       };
27306     } catch (...) {
27307       {
27308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27309       };
27310     }
27311   }
27312   jresult = (void *)result;
27313   return jresult;
27314 }
27315
27316
27317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
27318   void * jresult ;
27319   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27320   Dali::KeyEvent *arg2 = 0 ;
27321   Dali::KeyEvent *result = 0 ;
27322
27323   arg1 = (Dali::KeyEvent *)jarg1;
27324   arg2 = (Dali::KeyEvent *)jarg2;
27325   if (!arg2) {
27326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
27327     return 0;
27328   }
27329   {
27330     try {
27331       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
27332     } catch (std::out_of_range& e) {
27333       {
27334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27335       };
27336     } catch (std::exception& e) {
27337       {
27338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27339       };
27340     } catch (...) {
27341       {
27342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27343       };
27344     }
27345   }
27346   jresult = (void *)result;
27347   return jresult;
27348 }
27349
27350
27351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
27352   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27353
27354   arg1 = (Dali::KeyEvent *)jarg1;
27355   {
27356     try {
27357       delete arg1;
27358     } catch (std::out_of_range& e) {
27359       {
27360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27361       };
27362     } catch (std::exception& e) {
27363       {
27364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27365       };
27366     } catch (...) {
27367       {
27368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27369       };
27370     }
27371   }
27372 }
27373
27374
27375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
27376   unsigned int jresult ;
27377   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27378   bool result;
27379
27380   arg1 = (Dali::KeyEvent *)jarg1;
27381   {
27382     try {
27383       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
27384     } catch (std::out_of_range& e) {
27385       {
27386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27387       };
27388     } catch (std::exception& e) {
27389       {
27390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27391       };
27392     } catch (...) {
27393       {
27394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27395       };
27396     }
27397   }
27398   jresult = result;
27399   return jresult;
27400 }
27401
27402
27403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
27404   unsigned int jresult ;
27405   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27406   bool result;
27407
27408   arg1 = (Dali::KeyEvent *)jarg1;
27409   {
27410     try {
27411       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
27412     } catch (std::out_of_range& e) {
27413       {
27414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27415       };
27416     } catch (std::exception& e) {
27417       {
27418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27419       };
27420     } catch (...) {
27421       {
27422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27423       };
27424     }
27425   }
27426   jresult = result;
27427   return jresult;
27428 }
27429
27430
27431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
27432   unsigned int jresult ;
27433   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27434   bool result;
27435
27436   arg1 = (Dali::KeyEvent *)jarg1;
27437   {
27438     try {
27439       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
27440     } catch (std::out_of_range& e) {
27441       {
27442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27443       };
27444     } catch (std::exception& e) {
27445       {
27446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27447       };
27448     } catch (...) {
27449       {
27450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27451       };
27452     }
27453   }
27454   jresult = result;
27455   return jresult;
27456 }
27457
27458
27459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
27460   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27461   std::string *arg2 = 0 ;
27462
27463   arg1 = (Dali::KeyEvent *)jarg1;
27464   if (!jarg2) {
27465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27466     return ;
27467   }
27468   std::string arg2_str(jarg2);
27469   arg2 = &arg2_str;
27470   if (arg1) (arg1)->keyPressedName = *arg2;
27471
27472   //argout typemap for const std::string&
27473
27474 }
27475
27476
27477 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
27478   char * jresult ;
27479   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27480   std::string *result = 0 ;
27481
27482   arg1 = (Dali::KeyEvent *)jarg1;
27483   result = (std::string *) & ((arg1)->keyPressedName);
27484   jresult = SWIG_csharp_string_callback(result->c_str());
27485   return jresult;
27486 }
27487
27488
27489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
27490   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27491   std::string *arg2 = 0 ;
27492
27493   arg1 = (Dali::KeyEvent *)jarg1;
27494   if (!jarg2) {
27495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
27496     return ;
27497   }
27498   std::string arg2_str(jarg2);
27499   arg2 = &arg2_str;
27500   if (arg1) (arg1)->keyPressed = *arg2;
27501
27502   //argout typemap for const std::string&
27503
27504 }
27505
27506
27507 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
27508   char * jresult ;
27509   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27510   std::string *result = 0 ;
27511
27512   arg1 = (Dali::KeyEvent *)jarg1;
27513   result = (std::string *) & ((arg1)->keyPressed);
27514   jresult = SWIG_csharp_string_callback(result->c_str());
27515   return jresult;
27516 }
27517
27518
27519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
27520   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27521   int arg2 ;
27522
27523   arg1 = (Dali::KeyEvent *)jarg1;
27524   arg2 = (int)jarg2;
27525   if (arg1) (arg1)->keyCode = arg2;
27526 }
27527
27528
27529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
27530   int jresult ;
27531   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27532   int result;
27533
27534   arg1 = (Dali::KeyEvent *)jarg1;
27535   result = (int) ((arg1)->keyCode);
27536   jresult = result;
27537   return jresult;
27538 }
27539
27540
27541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
27542   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27543   int arg2 ;
27544
27545   arg1 = (Dali::KeyEvent *)jarg1;
27546   arg2 = (int)jarg2;
27547   if (arg1) (arg1)->keyModifier = arg2;
27548 }
27549
27550
27551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
27552   int jresult ;
27553   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27554   int result;
27555
27556   arg1 = (Dali::KeyEvent *)jarg1;
27557   result = (int) ((arg1)->keyModifier);
27558   jresult = result;
27559   return jresult;
27560 }
27561
27562
27563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
27564   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27565   unsigned long arg2 ;
27566
27567   arg1 = (Dali::KeyEvent *)jarg1;
27568   arg2 = (unsigned long)jarg2;
27569   if (arg1) (arg1)->time = arg2;
27570 }
27571
27572
27573 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
27574   unsigned long jresult ;
27575   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27576   unsigned long result;
27577
27578   arg1 = (Dali::KeyEvent *)jarg1;
27579   result = (unsigned long) ((arg1)->time);
27580   jresult = (unsigned long)result;
27581   return jresult;
27582 }
27583
27584
27585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
27586   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27587   Dali::KeyEvent::State arg2 ;
27588
27589   arg1 = (Dali::KeyEvent *)jarg1;
27590   arg2 = (Dali::KeyEvent::State)jarg2;
27591   if (arg1) (arg1)->state = arg2;
27592 }
27593
27594
27595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
27596   int jresult ;
27597   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
27598   Dali::KeyEvent::State result;
27599
27600   arg1 = (Dali::KeyEvent *)jarg1;
27601   result = (Dali::KeyEvent::State) ((arg1)->state);
27602   jresult = (int)result;
27603   return jresult;
27604 }
27605
27606
27607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
27608   void * jresult ;
27609   Dali::LongPressGestureDetector *result = 0 ;
27610
27611   {
27612     try {
27613       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
27614     } catch (std::out_of_range& e) {
27615       {
27616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27617       };
27618     } catch (std::exception& e) {
27619       {
27620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27621       };
27622     } catch (...) {
27623       {
27624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27625       };
27626     }
27627   }
27628   jresult = (void *)result;
27629   return jresult;
27630 }
27631
27632
27633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
27634   void * jresult ;
27635   Dali::LongPressGestureDetector result;
27636
27637   {
27638     try {
27639       result = Dali::LongPressGestureDetector::New();
27640     } catch (std::out_of_range& e) {
27641       {
27642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27643       };
27644     } catch (std::exception& e) {
27645       {
27646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27647       };
27648     } catch (...) {
27649       {
27650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27651       };
27652     }
27653   }
27654   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27655   return jresult;
27656 }
27657
27658
27659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
27660   void * jresult ;
27661   unsigned int arg1 ;
27662   Dali::LongPressGestureDetector result;
27663
27664   arg1 = (unsigned int)jarg1;
27665   {
27666     try {
27667       result = Dali::LongPressGestureDetector::New(arg1);
27668     } catch (std::out_of_range& e) {
27669       {
27670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27671       };
27672     } catch (std::exception& e) {
27673       {
27674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27675       };
27676     } catch (...) {
27677       {
27678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27679       };
27680     }
27681   }
27682   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27683   return jresult;
27684 }
27685
27686
27687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
27688   void * jresult ;
27689   unsigned int arg1 ;
27690   unsigned int arg2 ;
27691   Dali::LongPressGestureDetector result;
27692
27693   arg1 = (unsigned int)jarg1;
27694   arg2 = (unsigned int)jarg2;
27695   {
27696     try {
27697       result = Dali::LongPressGestureDetector::New(arg1,arg2);
27698     } catch (std::out_of_range& e) {
27699       {
27700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27701       };
27702     } catch (std::exception& e) {
27703       {
27704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27705       };
27706     } catch (...) {
27707       {
27708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27709       };
27710     }
27711   }
27712   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27713   return jresult;
27714 }
27715
27716
27717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
27718   void * jresult ;
27719   Dali::BaseHandle arg1 ;
27720   Dali::BaseHandle *argp1 ;
27721   Dali::LongPressGestureDetector result;
27722
27723   argp1 = (Dali::BaseHandle *)jarg1;
27724   if (!argp1) {
27725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27726     return 0;
27727   }
27728   arg1 = *argp1;
27729   {
27730     try {
27731       result = Dali::LongPressGestureDetector::DownCast(arg1);
27732     } catch (std::out_of_range& e) {
27733       {
27734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27735       };
27736     } catch (std::exception& e) {
27737       {
27738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27739       };
27740     } catch (...) {
27741       {
27742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27743       };
27744     }
27745   }
27746   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
27747   return jresult;
27748 }
27749
27750
27751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
27752   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27753
27754   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27755   {
27756     try {
27757       delete arg1;
27758     } catch (std::out_of_range& e) {
27759       {
27760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27761       };
27762     } catch (std::exception& e) {
27763       {
27764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27765       };
27766     } catch (...) {
27767       {
27768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27769       };
27770     }
27771   }
27772 }
27773
27774
27775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
27776   void * jresult ;
27777   Dali::LongPressGestureDetector *arg1 = 0 ;
27778   Dali::LongPressGestureDetector *result = 0 ;
27779
27780   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27781   if (!arg1) {
27782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27783     return 0;
27784   }
27785   {
27786     try {
27787       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
27788     } catch (std::out_of_range& e) {
27789       {
27790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27791       };
27792     } catch (std::exception& e) {
27793       {
27794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27795       };
27796     } catch (...) {
27797       {
27798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27799       };
27800     }
27801   }
27802   jresult = (void *)result;
27803   return jresult;
27804 }
27805
27806
27807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
27808   void * jresult ;
27809   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27810   Dali::LongPressGestureDetector *arg2 = 0 ;
27811   Dali::LongPressGestureDetector *result = 0 ;
27812
27813   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27814   arg2 = (Dali::LongPressGestureDetector *)jarg2;
27815   if (!arg2) {
27816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
27817     return 0;
27818   }
27819   {
27820     try {
27821       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
27822     } catch (std::out_of_range& e) {
27823       {
27824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27825       };
27826     } catch (std::exception& e) {
27827       {
27828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27829       };
27830     } catch (...) {
27831       {
27832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27833       };
27834     }
27835   }
27836   jresult = (void *)result;
27837   return jresult;
27838 }
27839
27840
27841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
27842   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27843   unsigned int arg2 ;
27844
27845   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27846   arg2 = (unsigned int)jarg2;
27847   {
27848     try {
27849       (arg1)->SetTouchesRequired(arg2);
27850     } catch (std::out_of_range& e) {
27851       {
27852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27853       };
27854     } catch (std::exception& e) {
27855       {
27856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27857       };
27858     } catch (...) {
27859       {
27860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27861       };
27862     }
27863   }
27864 }
27865
27866
27867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
27868   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27869   unsigned int arg2 ;
27870   unsigned int arg3 ;
27871
27872   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27873   arg2 = (unsigned int)jarg2;
27874   arg3 = (unsigned int)jarg3;
27875   {
27876     try {
27877       (arg1)->SetTouchesRequired(arg2,arg3);
27878     } catch (std::out_of_range& e) {
27879       {
27880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27881       };
27882     } catch (std::exception& e) {
27883       {
27884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27885       };
27886     } catch (...) {
27887       {
27888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27889       };
27890     }
27891   }
27892 }
27893
27894
27895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
27896   unsigned int jresult ;
27897   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27898   unsigned int result;
27899
27900   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27901   {
27902     try {
27903       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
27904     } catch (std::out_of_range& e) {
27905       {
27906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27907       };
27908     } catch (std::exception& e) {
27909       {
27910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27911       };
27912     } catch (...) {
27913       {
27914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27915       };
27916     }
27917   }
27918   jresult = result;
27919   return jresult;
27920 }
27921
27922
27923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
27924   unsigned int jresult ;
27925   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27926   unsigned int result;
27927
27928   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27929   {
27930     try {
27931       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
27932     } catch (std::out_of_range& e) {
27933       {
27934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27935       };
27936     } catch (std::exception& e) {
27937       {
27938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27939       };
27940     } catch (...) {
27941       {
27942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27943       };
27944     }
27945   }
27946   jresult = result;
27947   return jresult;
27948 }
27949
27950
27951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
27952   void * jresult ;
27953   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
27954   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
27955
27956   arg1 = (Dali::LongPressGestureDetector *)jarg1;
27957   {
27958     try {
27959       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
27960     } catch (std::out_of_range& e) {
27961       {
27962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27963       };
27964     } catch (std::exception& e) {
27965       {
27966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27967       };
27968     } catch (...) {
27969       {
27970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27971       };
27972     }
27973   }
27974   jresult = (void *)result;
27975   return jresult;
27976 }
27977
27978
27979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
27980   void * jresult ;
27981   Dali::Gesture::State arg1 ;
27982   Dali::LongPressGesture *result = 0 ;
27983
27984   arg1 = (Dali::Gesture::State)jarg1;
27985   {
27986     try {
27987       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
27988     } catch (std::out_of_range& e) {
27989       {
27990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27991       };
27992     } catch (std::exception& e) {
27993       {
27994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27995       };
27996     } catch (...) {
27997       {
27998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27999       };
28000     }
28001   }
28002   jresult = (void *)result;
28003   return jresult;
28004 }
28005
28006
28007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
28008   void * jresult ;
28009   Dali::LongPressGesture *arg1 = 0 ;
28010   Dali::LongPressGesture *result = 0 ;
28011
28012   arg1 = (Dali::LongPressGesture *)jarg1;
28013   if (!arg1) {
28014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28015     return 0;
28016   }
28017   {
28018     try {
28019       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
28020     } catch (std::out_of_range& e) {
28021       {
28022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28023       };
28024     } catch (std::exception& e) {
28025       {
28026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28027       };
28028     } catch (...) {
28029       {
28030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28031       };
28032     }
28033   }
28034   jresult = (void *)result;
28035   return jresult;
28036 }
28037
28038
28039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
28040   void * jresult ;
28041   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28042   Dali::LongPressGesture *arg2 = 0 ;
28043   Dali::LongPressGesture *result = 0 ;
28044
28045   arg1 = (Dali::LongPressGesture *)jarg1;
28046   arg2 = (Dali::LongPressGesture *)jarg2;
28047   if (!arg2) {
28048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
28049     return 0;
28050   }
28051   {
28052     try {
28053       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
28054     } catch (std::out_of_range& e) {
28055       {
28056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28057       };
28058     } catch (std::exception& e) {
28059       {
28060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28061       };
28062     } catch (...) {
28063       {
28064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28065       };
28066     }
28067   }
28068   jresult = (void *)result;
28069   return jresult;
28070 }
28071
28072
28073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
28074   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28075
28076   arg1 = (Dali::LongPressGesture *)jarg1;
28077   {
28078     try {
28079       delete arg1;
28080     } catch (std::out_of_range& e) {
28081       {
28082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28083       };
28084     } catch (std::exception& e) {
28085       {
28086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28087       };
28088     } catch (...) {
28089       {
28090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28091       };
28092     }
28093   }
28094 }
28095
28096
28097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
28098   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28099   unsigned int arg2 ;
28100
28101   arg1 = (Dali::LongPressGesture *)jarg1;
28102   arg2 = (unsigned int)jarg2;
28103   if (arg1) (arg1)->numberOfTouches = arg2;
28104 }
28105
28106
28107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
28108   unsigned int jresult ;
28109   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28110   unsigned int result;
28111
28112   arg1 = (Dali::LongPressGesture *)jarg1;
28113   result = (unsigned int) ((arg1)->numberOfTouches);
28114   jresult = result;
28115   return jresult;
28116 }
28117
28118
28119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
28120   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28121   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28122
28123   arg1 = (Dali::LongPressGesture *)jarg1;
28124   arg2 = (Dali::Vector2 *)jarg2;
28125   if (arg1) (arg1)->screenPoint = *arg2;
28126 }
28127
28128
28129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
28130   void * jresult ;
28131   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28132   Dali::Vector2 *result = 0 ;
28133
28134   arg1 = (Dali::LongPressGesture *)jarg1;
28135   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
28136   jresult = (void *)result;
28137   return jresult;
28138 }
28139
28140
28141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
28142   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28143   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28144
28145   arg1 = (Dali::LongPressGesture *)jarg1;
28146   arg2 = (Dali::Vector2 *)jarg2;
28147   if (arg1) (arg1)->localPoint = *arg2;
28148 }
28149
28150
28151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
28152   void * jresult ;
28153   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
28154   Dali::Vector2 *result = 0 ;
28155
28156   arg1 = (Dali::LongPressGesture *)jarg1;
28157   result = (Dali::Vector2 *)& ((arg1)->localPoint);
28158   jresult = (void *)result;
28159   return jresult;
28160 }
28161
28162
28163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
28164   void * jresult ;
28165   Dali::WheelEvent *result = 0 ;
28166
28167   {
28168     try {
28169       result = (Dali::WheelEvent *)new Dali::WheelEvent();
28170     } catch (std::out_of_range& e) {
28171       {
28172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28173       };
28174     } catch (std::exception& e) {
28175       {
28176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28177       };
28178     } catch (...) {
28179       {
28180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28181       };
28182     }
28183   }
28184   jresult = (void *)result;
28185   return jresult;
28186 }
28187
28188
28189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
28190   void * jresult ;
28191   Dali::WheelEvent::Type arg1 ;
28192   int arg2 ;
28193   unsigned int arg3 ;
28194   Dali::Vector2 arg4 ;
28195   int arg5 ;
28196   unsigned int arg6 ;
28197   Dali::Vector2 *argp4 ;
28198   Dali::WheelEvent *result = 0 ;
28199
28200   arg1 = (Dali::WheelEvent::Type)jarg1;
28201   arg2 = (int)jarg2;
28202   arg3 = (unsigned int)jarg3;
28203   argp4 = (Dali::Vector2 *)jarg4;
28204   if (!argp4) {
28205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28206     return 0;
28207   }
28208   arg4 = *argp4;
28209   arg5 = (int)jarg5;
28210   arg6 = (unsigned int)jarg6;
28211   {
28212     try {
28213       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
28214     } catch (std::out_of_range& e) {
28215       {
28216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28217       };
28218     } catch (std::exception& e) {
28219       {
28220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28221       };
28222     } catch (...) {
28223       {
28224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28225       };
28226     }
28227   }
28228   jresult = (void *)result;
28229   return jresult;
28230 }
28231
28232
28233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
28234   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28235
28236   arg1 = (Dali::WheelEvent *)jarg1;
28237   {
28238     try {
28239       delete arg1;
28240     } catch (std::out_of_range& e) {
28241       {
28242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28243       };
28244     } catch (std::exception& e) {
28245       {
28246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28247       };
28248     } catch (...) {
28249       {
28250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28251       };
28252     }
28253   }
28254 }
28255
28256
28257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
28258   unsigned int jresult ;
28259   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28260   bool result;
28261
28262   arg1 = (Dali::WheelEvent *)jarg1;
28263   {
28264     try {
28265       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
28266     } catch (std::out_of_range& e) {
28267       {
28268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28269       };
28270     } catch (std::exception& e) {
28271       {
28272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28273       };
28274     } catch (...) {
28275       {
28276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28277       };
28278     }
28279   }
28280   jresult = result;
28281   return jresult;
28282 }
28283
28284
28285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
28286   unsigned int jresult ;
28287   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28288   bool result;
28289
28290   arg1 = (Dali::WheelEvent *)jarg1;
28291   {
28292     try {
28293       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
28294     } catch (std::out_of_range& e) {
28295       {
28296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28297       };
28298     } catch (std::exception& e) {
28299       {
28300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28301       };
28302     } catch (...) {
28303       {
28304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28305       };
28306     }
28307   }
28308   jresult = result;
28309   return jresult;
28310 }
28311
28312
28313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
28314   unsigned int jresult ;
28315   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28316   bool result;
28317
28318   arg1 = (Dali::WheelEvent *)jarg1;
28319   {
28320     try {
28321       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
28322     } catch (std::out_of_range& e) {
28323       {
28324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28325       };
28326     } catch (std::exception& e) {
28327       {
28328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28329       };
28330     } catch (...) {
28331       {
28332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28333       };
28334     }
28335   }
28336   jresult = result;
28337   return jresult;
28338 }
28339
28340
28341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
28342   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28343   Dali::WheelEvent::Type arg2 ;
28344
28345   arg1 = (Dali::WheelEvent *)jarg1;
28346   arg2 = (Dali::WheelEvent::Type)jarg2;
28347   if (arg1) (arg1)->type = arg2;
28348 }
28349
28350
28351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
28352   int jresult ;
28353   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28354   Dali::WheelEvent::Type result;
28355
28356   arg1 = (Dali::WheelEvent *)jarg1;
28357   result = (Dali::WheelEvent::Type) ((arg1)->type);
28358   jresult = (int)result;
28359   return jresult;
28360 }
28361
28362
28363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
28364   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28365   int arg2 ;
28366
28367   arg1 = (Dali::WheelEvent *)jarg1;
28368   arg2 = (int)jarg2;
28369   if (arg1) (arg1)->direction = arg2;
28370 }
28371
28372
28373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
28374   int jresult ;
28375   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28376   int result;
28377
28378   arg1 = (Dali::WheelEvent *)jarg1;
28379   result = (int) ((arg1)->direction);
28380   jresult = result;
28381   return jresult;
28382 }
28383
28384
28385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
28386   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28387   unsigned int arg2 ;
28388
28389   arg1 = (Dali::WheelEvent *)jarg1;
28390   arg2 = (unsigned int)jarg2;
28391   if (arg1) (arg1)->modifiers = arg2;
28392 }
28393
28394
28395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
28396   unsigned int jresult ;
28397   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28398   unsigned int result;
28399
28400   arg1 = (Dali::WheelEvent *)jarg1;
28401   result = (unsigned int) ((arg1)->modifiers);
28402   jresult = result;
28403   return jresult;
28404 }
28405
28406
28407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
28408   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28409   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
28410
28411   arg1 = (Dali::WheelEvent *)jarg1;
28412   arg2 = (Dali::Vector2 *)jarg2;
28413   if (arg1) (arg1)->point = *arg2;
28414 }
28415
28416
28417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
28418   void * jresult ;
28419   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28420   Dali::Vector2 *result = 0 ;
28421
28422   arg1 = (Dali::WheelEvent *)jarg1;
28423   result = (Dali::Vector2 *)& ((arg1)->point);
28424   jresult = (void *)result;
28425   return jresult;
28426 }
28427
28428
28429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
28430   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28431   int arg2 ;
28432
28433   arg1 = (Dali::WheelEvent *)jarg1;
28434   arg2 = (int)jarg2;
28435   if (arg1) (arg1)->z = arg2;
28436 }
28437
28438
28439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
28440   int jresult ;
28441   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28442   int result;
28443
28444   arg1 = (Dali::WheelEvent *)jarg1;
28445   result = (int) ((arg1)->z);
28446   jresult = result;
28447   return jresult;
28448 }
28449
28450
28451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
28452   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28453   unsigned int arg2 ;
28454
28455   arg1 = (Dali::WheelEvent *)jarg1;
28456   arg2 = (unsigned int)jarg2;
28457   if (arg1) (arg1)->timeStamp = arg2;
28458 }
28459
28460
28461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
28462   unsigned int jresult ;
28463   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
28464   unsigned int result;
28465
28466   arg1 = (Dali::WheelEvent *)jarg1;
28467   result = (unsigned int) ((arg1)->timeStamp);
28468   jresult = result;
28469   return jresult;
28470 }
28471
28472 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
28473   char * jresult ;
28474   Dali::KeyEvent *arg1 = 0 ;
28475   std::string result;
28476
28477   arg1 = (Dali::KeyEvent *)jarg1;
28478   if (!arg1) {
28479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28480     return 0;
28481   }
28482   {
28483     try {
28484       result = Dali::DevelKeyEvent::GetDeviceName((Dali::KeyEvent const &)*arg1);
28485     } catch (std::out_of_range& e) {
28486       {
28487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28488       };
28489     } catch (std::exception& e) {
28490       {
28491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28492       };
28493     } catch (...) {
28494       {
28495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28496       };
28497     }
28498   }
28499   jresult = SWIG_csharp_string_callback((&result)->c_str());
28500   return jresult;
28501 }
28502
28503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
28504   int jresult ;
28505   Dali::KeyEvent *arg1 = 0 ;
28506   Dali::DevelKeyEvent::DeviceClass::Type result;
28507
28508   arg1 = (Dali::KeyEvent *)jarg1;
28509   if (!arg1) {
28510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
28511     return 0;
28512   }
28513   {
28514     try {
28515       result = (Dali::DevelKeyEvent::DeviceClass::Type)Dali::DevelKeyEvent::GetDeviceClass((Dali::KeyEvent const &)*arg1);
28516     } catch (std::out_of_range& e) {
28517       {
28518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28519       };
28520     } catch (std::exception& e) {
28521       {
28522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28523       };
28524     } catch (...) {
28525       {
28526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28527       };
28528     }
28529   }
28530   jresult = (int)result;
28531   return jresult;
28532 }
28533
28534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
28535   int jresult ;
28536   int result;
28537
28538   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
28539   jresult = (int)result;
28540   return jresult;
28541 }
28542
28543
28544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
28545   int jresult ;
28546   int result;
28547
28548   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
28549   jresult = (int)result;
28550   return jresult;
28551 }
28552
28553
28554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
28555   int jresult ;
28556   int result;
28557
28558   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
28559   jresult = (int)result;
28560   return jresult;
28561 }
28562
28563
28564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
28565   int jresult ;
28566   int result;
28567
28568   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
28569   jresult = (int)result;
28570   return jresult;
28571 }
28572
28573
28574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
28575   int jresult ;
28576   int result;
28577
28578   result = (int)Dali::Actor::Property::ANCHOR_POINT;
28579   jresult = (int)result;
28580   return jresult;
28581 }
28582
28583
28584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
28585   int jresult ;
28586   int result;
28587
28588   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
28589   jresult = (int)result;
28590   return jresult;
28591 }
28592
28593
28594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
28595   int jresult ;
28596   int result;
28597
28598   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
28599   jresult = (int)result;
28600   return jresult;
28601 }
28602
28603
28604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
28605   int jresult ;
28606   int result;
28607
28608   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
28609   jresult = (int)result;
28610   return jresult;
28611 }
28612
28613
28614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
28615   int jresult ;
28616   int result;
28617
28618   result = (int)Dali::Actor::Property::SIZE;
28619   jresult = (int)result;
28620   return jresult;
28621 }
28622
28623
28624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
28625   int jresult ;
28626   int result;
28627
28628   result = (int)Dali::Actor::Property::SIZE_WIDTH;
28629   jresult = (int)result;
28630   return jresult;
28631 }
28632
28633
28634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
28635   int jresult ;
28636   int result;
28637
28638   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
28639   jresult = (int)result;
28640   return jresult;
28641 }
28642
28643
28644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
28645   int jresult ;
28646   int result;
28647
28648   result = (int)Dali::Actor::Property::SIZE_DEPTH;
28649   jresult = (int)result;
28650   return jresult;
28651 }
28652
28653
28654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
28655   int jresult ;
28656   int result;
28657
28658   result = (int)Dali::Actor::Property::POSITION;
28659   jresult = (int)result;
28660   return jresult;
28661 }
28662
28663
28664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
28665   int jresult ;
28666   int result;
28667
28668   result = (int)Dali::Actor::Property::POSITION_X;
28669   jresult = (int)result;
28670   return jresult;
28671 }
28672
28673
28674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
28675   int jresult ;
28676   int result;
28677
28678   result = (int)Dali::Actor::Property::POSITION_Y;
28679   jresult = (int)result;
28680   return jresult;
28681 }
28682
28683
28684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
28685   int jresult ;
28686   int result;
28687
28688   result = (int)Dali::Actor::Property::POSITION_Z;
28689   jresult = (int)result;
28690   return jresult;
28691 }
28692
28693
28694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
28695   int jresult ;
28696   int result;
28697
28698   result = (int)Dali::Actor::Property::WORLD_POSITION;
28699   jresult = (int)result;
28700   return jresult;
28701 }
28702
28703
28704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
28705   int jresult ;
28706   int result;
28707
28708   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
28709   jresult = (int)result;
28710   return jresult;
28711 }
28712
28713
28714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
28715   int jresult ;
28716   int result;
28717
28718   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
28719   jresult = (int)result;
28720   return jresult;
28721 }
28722
28723
28724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
28725   int jresult ;
28726   int result;
28727
28728   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
28729   jresult = (int)result;
28730   return jresult;
28731 }
28732
28733
28734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
28735   int jresult ;
28736   int result;
28737
28738   result = (int)Dali::Actor::Property::ORIENTATION;
28739   jresult = (int)result;
28740   return jresult;
28741 }
28742
28743
28744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
28745   int jresult ;
28746   int result;
28747
28748   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
28749   jresult = (int)result;
28750   return jresult;
28751 }
28752
28753
28754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
28755   int jresult ;
28756   int result;
28757
28758   result = (int)Dali::Actor::Property::SCALE;
28759   jresult = (int)result;
28760   return jresult;
28761 }
28762
28763
28764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
28765   int jresult ;
28766   int result;
28767
28768   result = (int)Dali::Actor::Property::SCALE_X;
28769   jresult = (int)result;
28770   return jresult;
28771 }
28772
28773
28774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
28775   int jresult ;
28776   int result;
28777
28778   result = (int)Dali::Actor::Property::SCALE_Y;
28779   jresult = (int)result;
28780   return jresult;
28781 }
28782
28783
28784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
28785   int jresult ;
28786   int result;
28787
28788   result = (int)Dali::Actor::Property::SCALE_Z;
28789   jresult = (int)result;
28790   return jresult;
28791 }
28792
28793
28794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
28795   int jresult ;
28796   int result;
28797
28798   result = (int)Dali::Actor::Property::WORLD_SCALE;
28799   jresult = (int)result;
28800   return jresult;
28801 }
28802
28803
28804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
28805   int jresult ;
28806   int result;
28807
28808   result = (int)Dali::Actor::Property::VISIBLE;
28809   jresult = (int)result;
28810   return jresult;
28811 }
28812
28813
28814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
28815   int jresult ;
28816   int result;
28817
28818   result = (int)Dali::Actor::Property::COLOR;
28819   jresult = (int)result;
28820   return jresult;
28821 }
28822
28823
28824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
28825   int jresult ;
28826   int result;
28827
28828   result = (int)Dali::Actor::Property::COLOR_RED;
28829   jresult = (int)result;
28830   return jresult;
28831 }
28832
28833
28834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
28835   int jresult ;
28836   int result;
28837
28838   result = (int)Dali::Actor::Property::COLOR_GREEN;
28839   jresult = (int)result;
28840   return jresult;
28841 }
28842
28843
28844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
28845   int jresult ;
28846   int result;
28847
28848   result = (int)Dali::Actor::Property::COLOR_BLUE;
28849   jresult = (int)result;
28850   return jresult;
28851 }
28852
28853
28854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
28855   int jresult ;
28856   int result;
28857
28858   result = (int)Dali::Actor::Property::COLOR_ALPHA;
28859   jresult = (int)result;
28860   return jresult;
28861 }
28862
28863
28864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
28865   int jresult ;
28866   int result;
28867
28868   result = (int)Dali::Actor::Property::WORLD_COLOR;
28869   jresult = (int)result;
28870   return jresult;
28871 }
28872
28873
28874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
28875   int jresult ;
28876   int result;
28877
28878   result = (int)Dali::Actor::Property::WORLD_MATRIX;
28879   jresult = (int)result;
28880   return jresult;
28881 }
28882
28883
28884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
28885   int jresult ;
28886   int result;
28887
28888   result = (int)Dali::Actor::Property::NAME;
28889   jresult = (int)result;
28890   return jresult;
28891 }
28892
28893
28894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
28895   int jresult ;
28896   int result;
28897
28898   result = (int)Dali::Actor::Property::SENSITIVE;
28899   jresult = (int)result;
28900   return jresult;
28901 }
28902
28903
28904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
28905   int jresult ;
28906   int result;
28907
28908   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
28909   jresult = (int)result;
28910   return jresult;
28911 }
28912
28913
28914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
28915   int jresult ;
28916   int result;
28917
28918   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
28919   jresult = (int)result;
28920   return jresult;
28921 }
28922
28923
28924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
28925   int jresult ;
28926   int result;
28927
28928   result = (int)Dali::Actor::Property::INHERIT_SCALE;
28929   jresult = (int)result;
28930   return jresult;
28931 }
28932
28933
28934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
28935   int jresult ;
28936   int result;
28937
28938   result = (int)Dali::Actor::Property::COLOR_MODE;
28939   jresult = (int)result;
28940   return jresult;
28941 }
28942
28943
28944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
28945   int jresult ;
28946   int result;
28947
28948   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
28949   jresult = (int)result;
28950   return jresult;
28951 }
28952
28953
28954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
28955   int jresult ;
28956   int result;
28957
28958   result = (int)Dali::Actor::Property::DRAW_MODE;
28959   jresult = (int)result;
28960   return jresult;
28961 }
28962
28963
28964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
28965   int jresult ;
28966   int result;
28967
28968   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
28969   jresult = (int)result;
28970   return jresult;
28971 }
28972
28973
28974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
28975   int jresult ;
28976   int result;
28977
28978   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
28979   jresult = (int)result;
28980   return jresult;
28981 }
28982
28983
28984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
28985   int jresult ;
28986   int result;
28987
28988   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
28989   jresult = (int)result;
28990   return jresult;
28991 }
28992
28993
28994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
28995   int jresult ;
28996   int result;
28997
28998   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
28999   jresult = (int)result;
29000   return jresult;
29001 }
29002
29003
29004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
29005   int jresult ;
29006   int result;
29007
29008   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
29009   jresult = (int)result;
29010   return jresult;
29011 }
29012
29013
29014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
29015   int jresult ;
29016   int result;
29017
29018   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
29019   jresult = (int)result;
29020   return jresult;
29021 }
29022
29023
29024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
29025   int jresult ;
29026   int result;
29027
29028   result = (int)Dali::Actor::Property::PADDING;
29029   jresult = (int)result;
29030   return jresult;
29031 }
29032
29033
29034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
29035   int jresult ;
29036   int result;
29037
29038   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
29039   jresult = (int)result;
29040   return jresult;
29041 }
29042
29043
29044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
29045   int jresult ;
29046   int result;
29047
29048   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
29049   jresult = (int)result;
29050   return jresult;
29051 }
29052
29053
29054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
29055   int jresult ;
29056   int result;
29057
29058   result = (int)Dali::Actor::Property::INHERIT_POSITION;
29059   jresult = (int)result;
29060   return jresult;
29061 }
29062
29063
29064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
29065   int jresult ;
29066   int result;
29067
29068   result = (int)Dali::Actor::Property::CLIPPING_MODE;
29069   jresult = (int)result;
29070   return jresult;
29071 }
29072
29073
29074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
29075   void * jresult ;
29076   Dali::Actor::Property *result = 0 ;
29077
29078   {
29079     try {
29080       result = (Dali::Actor::Property *)new Dali::Actor::Property();
29081     } catch (std::out_of_range& e) {
29082       {
29083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29084       };
29085     } catch (std::exception& e) {
29086       {
29087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29088       };
29089     } catch (...) {
29090       {
29091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29092       };
29093     }
29094   }
29095   jresult = (void *)result;
29096   return jresult;
29097 }
29098
29099
29100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
29101   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
29102
29103   arg1 = (Dali::Actor::Property *)jarg1;
29104   {
29105     try {
29106       delete arg1;
29107     } catch (std::out_of_range& e) {
29108       {
29109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29110       };
29111     } catch (std::exception& e) {
29112       {
29113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29114       };
29115     } catch (...) {
29116       {
29117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29118       };
29119     }
29120   }
29121 }
29122
29123
29124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
29125   void * jresult ;
29126   Dali::Actor *result = 0 ;
29127
29128   {
29129     try {
29130       result = (Dali::Actor *)new Dali::Actor();
29131     } catch (std::out_of_range& e) {
29132       {
29133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29134       };
29135     } catch (std::exception& e) {
29136       {
29137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29138       };
29139     } catch (...) {
29140       {
29141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29142       };
29143     }
29144   }
29145   jresult = (void *)result;
29146   return jresult;
29147 }
29148
29149
29150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
29151   void * jresult ;
29152   Dali::Actor result;
29153
29154   {
29155     try {
29156       result = Dali::Actor::New();
29157     } catch (std::out_of_range& e) {
29158       {
29159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29160       };
29161     } catch (std::exception& e) {
29162       {
29163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29164       };
29165     } catch (...) {
29166       {
29167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29168       };
29169     }
29170   }
29171   jresult = new Dali::Actor((const Dali::Actor &)result);
29172   return jresult;
29173 }
29174
29175
29176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
29177   void * jresult ;
29178   Dali::BaseHandle arg1 ;
29179   Dali::BaseHandle *argp1 ;
29180   Dali::Actor result;
29181
29182   argp1 = (Dali::BaseHandle *)jarg1;
29183   if (!argp1) {
29184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
29185     return 0;
29186   }
29187   arg1 = *argp1;
29188   {
29189     try {
29190       result = Dali::Actor::DownCast(arg1);
29191     } catch (std::out_of_range& e) {
29192       {
29193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29194       };
29195     } catch (std::exception& e) {
29196       {
29197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29198       };
29199     } catch (...) {
29200       {
29201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29202       };
29203     }
29204   }
29205   jresult = new Dali::Actor((const Dali::Actor &)result);
29206   return jresult;
29207 }
29208
29209
29210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
29211   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29212
29213   arg1 = (Dali::Actor *)jarg1;
29214   {
29215     try {
29216       delete arg1;
29217     } catch (std::out_of_range& e) {
29218       {
29219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29220       };
29221     } catch (std::exception& e) {
29222       {
29223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29224       };
29225     } catch (...) {
29226       {
29227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29228       };
29229     }
29230   }
29231 }
29232
29233
29234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
29235   void * jresult ;
29236   Dali::Actor *arg1 = 0 ;
29237   Dali::Actor *result = 0 ;
29238
29239   arg1 = (Dali::Actor *)jarg1;
29240   if (!arg1) {
29241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29242     return 0;
29243   }
29244   {
29245     try {
29246       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
29247     } catch (std::out_of_range& e) {
29248       {
29249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29250       };
29251     } catch (std::exception& e) {
29252       {
29253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29254       };
29255     } catch (...) {
29256       {
29257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29258       };
29259     }
29260   }
29261   jresult = (void *)result;
29262   return jresult;
29263 }
29264
29265
29266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
29267   void * jresult ;
29268   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29269   Dali::Actor *arg2 = 0 ;
29270   Dali::Actor *result = 0 ;
29271
29272   arg1 = (Dali::Actor *)jarg1;
29273   arg2 = (Dali::Actor *)jarg2;
29274   if (!arg2) {
29275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
29276     return 0;
29277   }
29278   {
29279     try {
29280       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
29281     } catch (std::out_of_range& e) {
29282       {
29283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29284       };
29285     } catch (std::exception& e) {
29286       {
29287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29288       };
29289     } catch (...) {
29290       {
29291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29292       };
29293     }
29294   }
29295   jresult = (void *)result;
29296   return jresult;
29297 }
29298
29299
29300 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
29301   char * jresult ;
29302   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29303   std::string *result = 0 ;
29304
29305   arg1 = (Dali::Actor *)jarg1;
29306   {
29307     try {
29308       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
29309     } catch (std::out_of_range& e) {
29310       {
29311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29312       };
29313     } catch (std::exception& e) {
29314       {
29315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29316       };
29317     } catch (...) {
29318       {
29319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29320       };
29321     }
29322   }
29323   jresult = SWIG_csharp_string_callback(result->c_str());
29324   return jresult;
29325 }
29326
29327
29328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
29329   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29330   std::string *arg2 = 0 ;
29331
29332   arg1 = (Dali::Actor *)jarg1;
29333   if (!jarg2) {
29334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29335     return ;
29336   }
29337   std::string arg2_str(jarg2);
29338   arg2 = &arg2_str;
29339   {
29340     try {
29341       (arg1)->SetName((std::string const &)*arg2);
29342     } catch (std::out_of_range& e) {
29343       {
29344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29345       };
29346     } catch (std::exception& e) {
29347       {
29348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29349       };
29350     } catch (...) {
29351       {
29352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29353       };
29354     }
29355   }
29356
29357   //argout typemap for const std::string&
29358
29359 }
29360
29361
29362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
29363   unsigned int jresult ;
29364   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29365   unsigned int result;
29366
29367   arg1 = (Dali::Actor *)jarg1;
29368   {
29369     try {
29370       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
29371     } catch (std::out_of_range& e) {
29372       {
29373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29374       };
29375     } catch (std::exception& e) {
29376       {
29377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29378       };
29379     } catch (...) {
29380       {
29381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29382       };
29383     }
29384   }
29385   jresult = result;
29386   return jresult;
29387 }
29388
29389
29390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
29391   unsigned int jresult ;
29392   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29393   bool result;
29394
29395   arg1 = (Dali::Actor *)jarg1;
29396   {
29397     try {
29398       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
29399     } catch (std::out_of_range& e) {
29400       {
29401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29402       };
29403     } catch (std::exception& e) {
29404       {
29405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29406       };
29407     } catch (...) {
29408       {
29409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29410       };
29411     }
29412   }
29413   jresult = result;
29414   return jresult;
29415 }
29416
29417
29418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
29419   unsigned int jresult ;
29420   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29421   bool result;
29422
29423   arg1 = (Dali::Actor *)jarg1;
29424   {
29425     try {
29426       result = (bool)((Dali::Actor const *)arg1)->OnStage();
29427     } catch (std::out_of_range& e) {
29428       {
29429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29430       };
29431     } catch (std::exception& e) {
29432       {
29433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29434       };
29435     } catch (...) {
29436       {
29437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29438       };
29439     }
29440   }
29441   jresult = result;
29442   return jresult;
29443 }
29444
29445
29446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
29447   unsigned int jresult ;
29448   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29449   bool result;
29450
29451   arg1 = (Dali::Actor *)jarg1;
29452   {
29453     try {
29454       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
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_GetLayer(void * jarg1) {
29475   void * jresult ;
29476   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29477   Dali::Layer result;
29478
29479   arg1 = (Dali::Actor *)jarg1;
29480   {
29481     try {
29482       result = (arg1)->GetLayer();
29483     } catch (std::out_of_range& e) {
29484       {
29485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29486       };
29487     } catch (std::exception& e) {
29488       {
29489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29490       };
29491     } catch (...) {
29492       {
29493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29494       };
29495     }
29496   }
29497   jresult = new Dali::Layer((const Dali::Layer &)result);
29498   return jresult;
29499 }
29500
29501
29502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
29503   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29504   Dali::Actor arg2 ;
29505   Dali::Actor *argp2 ;
29506
29507   arg1 = (Dali::Actor *)jarg1;
29508   argp2 = (Dali::Actor *)jarg2;
29509   if (!argp2) {
29510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29511     return ;
29512   }
29513   arg2 = *argp2;
29514   {
29515     try {
29516       (arg1)->Add(arg2);
29517     } catch (std::out_of_range& e) {
29518       {
29519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29520       };
29521     } catch (std::exception& e) {
29522       {
29523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29524       };
29525     } catch (...) {
29526       {
29527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29528       };
29529     }
29530   }
29531 }
29532
29533
29534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
29535   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29536   Dali::Actor arg2 ;
29537   Dali::Actor *argp2 ;
29538
29539   arg1 = (Dali::Actor *)jarg1;
29540   argp2 = (Dali::Actor *)jarg2;
29541   if (!argp2) {
29542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29543     return ;
29544   }
29545   arg2 = *argp2;
29546   {
29547     try {
29548       (arg1)->Remove(arg2);
29549     } catch (std::out_of_range& e) {
29550       {
29551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29552       };
29553     } catch (std::exception& e) {
29554       {
29555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29556       };
29557     } catch (...) {
29558       {
29559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29560       };
29561     }
29562   }
29563 }
29564
29565
29566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
29567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29568
29569   arg1 = (Dali::Actor *)jarg1;
29570   {
29571     try {
29572       (arg1)->Unparent();
29573     } catch (std::out_of_range& e) {
29574       {
29575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29576       };
29577     } catch (std::exception& e) {
29578       {
29579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29580       };
29581     } catch (...) {
29582       {
29583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29584       };
29585     }
29586   }
29587 }
29588
29589
29590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
29591   unsigned int jresult ;
29592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29593   unsigned int result;
29594
29595   arg1 = (Dali::Actor *)jarg1;
29596   {
29597     try {
29598       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
29599     } catch (std::out_of_range& e) {
29600       {
29601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29602       };
29603     } catch (std::exception& e) {
29604       {
29605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29606       };
29607     } catch (...) {
29608       {
29609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29610       };
29611     }
29612   }
29613   jresult = result;
29614   return jresult;
29615 }
29616
29617
29618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
29619   void * jresult ;
29620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29621   unsigned int arg2 ;
29622   Dali::Actor result;
29623
29624   arg1 = (Dali::Actor *)jarg1;
29625   arg2 = (unsigned int)jarg2;
29626   {
29627     try {
29628       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
29629     } catch (std::out_of_range& e) {
29630       {
29631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29632       };
29633     } catch (std::exception& e) {
29634       {
29635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29636       };
29637     } catch (...) {
29638       {
29639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29640       };
29641     }
29642   }
29643   jresult = new Dali::Actor((const Dali::Actor &)result);
29644   return jresult;
29645 }
29646
29647
29648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
29649   void * jresult ;
29650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29651   std::string *arg2 = 0 ;
29652   Dali::Actor result;
29653
29654   arg1 = (Dali::Actor *)jarg1;
29655   if (!jarg2) {
29656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
29657     return 0;
29658   }
29659   std::string arg2_str(jarg2);
29660   arg2 = &arg2_str;
29661   {
29662     try {
29663       result = (arg1)->FindChildByName((std::string const &)*arg2);
29664     } catch (std::out_of_range& e) {
29665       {
29666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29667       };
29668     } catch (std::exception& e) {
29669       {
29670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29671       };
29672     } catch (...) {
29673       {
29674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29675       };
29676     }
29677   }
29678   jresult = new Dali::Actor((const Dali::Actor &)result);
29679
29680   //argout typemap for const std::string&
29681
29682   return jresult;
29683 }
29684
29685
29686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
29687   void * jresult ;
29688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29689   unsigned int arg2 ;
29690   Dali::Actor result;
29691
29692   arg1 = (Dali::Actor *)jarg1;
29693   arg2 = (unsigned int)jarg2;
29694   {
29695     try {
29696       result = (arg1)->FindChildById(arg2);
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::Actor((const Dali::Actor &)result);
29712   return jresult;
29713 }
29714
29715
29716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
29717   void * jresult ;
29718   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29719   Dali::Actor result;
29720
29721   arg1 = (Dali::Actor *)jarg1;
29722   {
29723     try {
29724       result = ((Dali::Actor const *)arg1)->GetParent();
29725     } catch (std::out_of_range& e) {
29726       {
29727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29728       };
29729     } catch (std::exception& e) {
29730       {
29731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29732       };
29733     } catch (...) {
29734       {
29735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29736       };
29737     }
29738   }
29739   jresult = new Dali::Actor((const Dali::Actor &)result);
29740   return jresult;
29741 }
29742
29743
29744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
29745   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29746   Dali::Vector3 *arg2 = 0 ;
29747
29748   arg1 = (Dali::Actor *)jarg1;
29749   arg2 = (Dali::Vector3 *)jarg2;
29750   if (!arg2) {
29751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29752     return ;
29753   }
29754   {
29755     try {
29756       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
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_GetCurrentParentOrigin(void * jarg1) {
29775   void * jresult ;
29776   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29777   Dali::Vector3 result;
29778
29779   arg1 = (Dali::Actor *)jarg1;
29780   {
29781     try {
29782       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
29783     } catch (std::out_of_range& e) {
29784       {
29785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29786       };
29787     } catch (std::exception& e) {
29788       {
29789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29790       };
29791     } catch (...) {
29792       {
29793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29794       };
29795     }
29796   }
29797   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29798   return jresult;
29799 }
29800
29801
29802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
29803   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29804   Dali::Vector3 *arg2 = 0 ;
29805
29806   arg1 = (Dali::Actor *)jarg1;
29807   arg2 = (Dali::Vector3 *)jarg2;
29808   if (!arg2) {
29809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29810     return ;
29811   }
29812   {
29813     try {
29814       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
29815     } catch (std::out_of_range& e) {
29816       {
29817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29818       };
29819     } catch (std::exception& e) {
29820       {
29821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29822       };
29823     } catch (...) {
29824       {
29825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29826       };
29827     }
29828   }
29829 }
29830
29831
29832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
29833   void * jresult ;
29834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29835   Dali::Vector3 result;
29836
29837   arg1 = (Dali::Actor *)jarg1;
29838   {
29839     try {
29840       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
29841     } catch (std::out_of_range& e) {
29842       {
29843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29844       };
29845     } catch (std::exception& e) {
29846       {
29847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29848       };
29849     } catch (...) {
29850       {
29851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29852       };
29853     }
29854   }
29855   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
29856   return jresult;
29857 }
29858
29859
29860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
29861   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29862   float arg2 ;
29863   float arg3 ;
29864
29865   arg1 = (Dali::Actor *)jarg1;
29866   arg2 = (float)jarg2;
29867   arg3 = (float)jarg3;
29868   {
29869     try {
29870       (arg1)->SetSize(arg2,arg3);
29871     } catch (std::out_of_range& e) {
29872       {
29873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29874       };
29875     } catch (std::exception& e) {
29876       {
29877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29878       };
29879     } catch (...) {
29880       {
29881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29882       };
29883     }
29884   }
29885 }
29886
29887
29888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
29889   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29890   float arg2 ;
29891   float arg3 ;
29892   float arg4 ;
29893
29894   arg1 = (Dali::Actor *)jarg1;
29895   arg2 = (float)jarg2;
29896   arg3 = (float)jarg3;
29897   arg4 = (float)jarg4;
29898   {
29899     try {
29900       (arg1)->SetSize(arg2,arg3,arg4);
29901     } catch (std::out_of_range& e) {
29902       {
29903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29904       };
29905     } catch (std::exception& e) {
29906       {
29907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29908       };
29909     } catch (...) {
29910       {
29911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29912       };
29913     }
29914   }
29915 }
29916
29917
29918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
29919   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29920   Dali::Vector2 *arg2 = 0 ;
29921
29922   arg1 = (Dali::Actor *)jarg1;
29923   arg2 = (Dali::Vector2 *)jarg2;
29924   if (!arg2) {
29925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
29926     return ;
29927   }
29928   {
29929     try {
29930       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
29931     } catch (std::out_of_range& e) {
29932       {
29933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29934       };
29935     } catch (std::exception& e) {
29936       {
29937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29938       };
29939     } catch (...) {
29940       {
29941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29942       };
29943     }
29944   }
29945 }
29946
29947
29948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
29949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29950   Dali::Vector3 *arg2 = 0 ;
29951
29952   arg1 = (Dali::Actor *)jarg1;
29953   arg2 = (Dali::Vector3 *)jarg2;
29954   if (!arg2) {
29955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29956     return ;
29957   }
29958   {
29959     try {
29960       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
29961     } catch (std::out_of_range& e) {
29962       {
29963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29964       };
29965     } catch (std::exception& e) {
29966       {
29967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29968       };
29969     } catch (...) {
29970       {
29971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29972       };
29973     }
29974   }
29975 }
29976
29977
29978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
29979   void * jresult ;
29980   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
29981   Dali::Vector3 result;
29982
29983   arg1 = (Dali::Actor *)jarg1;
29984   {
29985     try {
29986       result = ((Dali::Actor const *)arg1)->GetTargetSize();
29987     } catch (std::out_of_range& e) {
29988       {
29989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29990       };
29991     } catch (std::exception& e) {
29992       {
29993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29994       };
29995     } catch (...) {
29996       {
29997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29998       };
29999     }
30000   }
30001   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30002   return jresult;
30003 }
30004
30005
30006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
30007   void * jresult ;
30008   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30009   Dali::Vector3 result;
30010
30011   arg1 = (Dali::Actor *)jarg1;
30012   {
30013     try {
30014       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
30015     } catch (std::out_of_range& e) {
30016       {
30017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30018       };
30019     } catch (std::exception& e) {
30020       {
30021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30022       };
30023     } catch (...) {
30024       {
30025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30026       };
30027     }
30028   }
30029   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30030   return jresult;
30031 }
30032
30033
30034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
30035   void * jresult ;
30036   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30037   Dali::Vector3 result;
30038
30039   arg1 = (Dali::Actor *)jarg1;
30040   {
30041     try {
30042       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
30043     } catch (std::out_of_range& e) {
30044       {
30045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30046       };
30047     } catch (std::exception& e) {
30048       {
30049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30050       };
30051     } catch (...) {
30052       {
30053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30054       };
30055     }
30056   }
30057   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30058   return jresult;
30059 }
30060
30061
30062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
30063   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30064   float arg2 ;
30065   float arg3 ;
30066
30067   arg1 = (Dali::Actor *)jarg1;
30068   arg2 = (float)jarg2;
30069   arg3 = (float)jarg3;
30070   {
30071     try {
30072       (arg1)->SetPosition(arg2,arg3);
30073     } catch (std::out_of_range& e) {
30074       {
30075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30076       };
30077     } catch (std::exception& e) {
30078       {
30079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30080       };
30081     } catch (...) {
30082       {
30083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30084       };
30085     }
30086   }
30087 }
30088
30089
30090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30091   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30092   float arg2 ;
30093   float arg3 ;
30094   float arg4 ;
30095
30096   arg1 = (Dali::Actor *)jarg1;
30097   arg2 = (float)jarg2;
30098   arg3 = (float)jarg3;
30099   arg4 = (float)jarg4;
30100   {
30101     try {
30102       (arg1)->SetPosition(arg2,arg3,arg4);
30103     } catch (std::out_of_range& e) {
30104       {
30105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30106       };
30107     } catch (std::exception& e) {
30108       {
30109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30110       };
30111     } catch (...) {
30112       {
30113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30114       };
30115     }
30116   }
30117 }
30118
30119
30120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
30121   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30122   Dali::Vector3 *arg2 = 0 ;
30123
30124   arg1 = (Dali::Actor *)jarg1;
30125   arg2 = (Dali::Vector3 *)jarg2;
30126   if (!arg2) {
30127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30128     return ;
30129   }
30130   {
30131     try {
30132       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
30133     } catch (std::out_of_range& e) {
30134       {
30135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30136       };
30137     } catch (std::exception& e) {
30138       {
30139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30140       };
30141     } catch (...) {
30142       {
30143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30144       };
30145     }
30146   }
30147 }
30148
30149
30150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
30151   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30152   float arg2 ;
30153
30154   arg1 = (Dali::Actor *)jarg1;
30155   arg2 = (float)jarg2;
30156   {
30157     try {
30158       (arg1)->SetX(arg2);
30159     } catch (std::out_of_range& e) {
30160       {
30161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30162       };
30163     } catch (std::exception& e) {
30164       {
30165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30166       };
30167     } catch (...) {
30168       {
30169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30170       };
30171     }
30172   }
30173 }
30174
30175
30176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
30177   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30178   float arg2 ;
30179
30180   arg1 = (Dali::Actor *)jarg1;
30181   arg2 = (float)jarg2;
30182   {
30183     try {
30184       (arg1)->SetY(arg2);
30185     } catch (std::out_of_range& e) {
30186       {
30187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30188       };
30189     } catch (std::exception& e) {
30190       {
30191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30192       };
30193     } catch (...) {
30194       {
30195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30196       };
30197     }
30198   }
30199 }
30200
30201
30202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
30203   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30204   float arg2 ;
30205
30206   arg1 = (Dali::Actor *)jarg1;
30207   arg2 = (float)jarg2;
30208   {
30209     try {
30210       (arg1)->SetZ(arg2);
30211     } catch (std::out_of_range& e) {
30212       {
30213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30214       };
30215     } catch (std::exception& e) {
30216       {
30217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30218       };
30219     } catch (...) {
30220       {
30221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30222       };
30223     }
30224   }
30225 }
30226
30227
30228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
30229   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30230   Dali::Vector3 *arg2 = 0 ;
30231
30232   arg1 = (Dali::Actor *)jarg1;
30233   arg2 = (Dali::Vector3 *)jarg2;
30234   if (!arg2) {
30235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30236     return ;
30237   }
30238   {
30239     try {
30240       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
30241     } catch (std::out_of_range& e) {
30242       {
30243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30244       };
30245     } catch (std::exception& e) {
30246       {
30247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30248       };
30249     } catch (...) {
30250       {
30251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30252       };
30253     }
30254   }
30255 }
30256
30257
30258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
30259   void * jresult ;
30260   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30261   Dali::Vector3 result;
30262
30263   arg1 = (Dali::Actor *)jarg1;
30264   {
30265     try {
30266       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
30267     } catch (std::out_of_range& e) {
30268       {
30269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30270       };
30271     } catch (std::exception& e) {
30272       {
30273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30274       };
30275     } catch (...) {
30276       {
30277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30278       };
30279     }
30280   }
30281   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30282   return jresult;
30283 }
30284
30285
30286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
30287   void * jresult ;
30288   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30289   Dali::Vector3 result;
30290
30291   arg1 = (Dali::Actor *)jarg1;
30292   {
30293     try {
30294       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
30295     } catch (std::out_of_range& e) {
30296       {
30297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30298       };
30299     } catch (std::exception& e) {
30300       {
30301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30302       };
30303     } catch (...) {
30304       {
30305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30306       };
30307     }
30308   }
30309   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30310   return jresult;
30311 }
30312
30313
30314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
30315   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30316   bool arg2 ;
30317
30318   arg1 = (Dali::Actor *)jarg1;
30319   arg2 = jarg2 ? true : false;
30320   {
30321     try {
30322       (arg1)->SetInheritPosition(arg2);
30323     } catch (std::out_of_range& e) {
30324       {
30325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30326       };
30327     } catch (std::exception& e) {
30328       {
30329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30330       };
30331     } catch (...) {
30332       {
30333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30334       };
30335     }
30336   }
30337 }
30338
30339
30340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
30341   int jresult ;
30342   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30343   Dali::PositionInheritanceMode result;
30344
30345   arg1 = (Dali::Actor *)jarg1;
30346   {
30347     try {
30348       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
30349     } catch (std::out_of_range& e) {
30350       {
30351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30352       };
30353     } catch (std::exception& e) {
30354       {
30355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30356       };
30357     } catch (...) {
30358       {
30359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30360       };
30361     }
30362   }
30363   jresult = (int)result;
30364   return jresult;
30365 }
30366
30367
30368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
30369   unsigned int jresult ;
30370   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30371   bool result;
30372
30373   arg1 = (Dali::Actor *)jarg1;
30374   {
30375     try {
30376       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
30377     } catch (std::out_of_range& e) {
30378       {
30379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30380       };
30381     } catch (std::exception& e) {
30382       {
30383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30384       };
30385     } catch (...) {
30386       {
30387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30388       };
30389     }
30390   }
30391   jresult = result;
30392   return jresult;
30393 }
30394
30395
30396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30397   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30398   Dali::Degree *arg2 = 0 ;
30399   Dali::Vector3 *arg3 = 0 ;
30400
30401   arg1 = (Dali::Actor *)jarg1;
30402   arg2 = (Dali::Degree *)jarg2;
30403   if (!arg2) {
30404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30405     return ;
30406   }
30407   arg3 = (Dali::Vector3 *)jarg3;
30408   if (!arg3) {
30409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30410     return ;
30411   }
30412   {
30413     try {
30414       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30415     } catch (std::out_of_range& e) {
30416       {
30417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30418       };
30419     } catch (std::exception& e) {
30420       {
30421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30422       };
30423     } catch (...) {
30424       {
30425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30426       };
30427     }
30428   }
30429 }
30430
30431
30432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30433   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30434   Dali::Radian *arg2 = 0 ;
30435   Dali::Vector3 *arg3 = 0 ;
30436
30437   arg1 = (Dali::Actor *)jarg1;
30438   arg2 = (Dali::Radian *)jarg2;
30439   if (!arg2) {
30440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30441     return ;
30442   }
30443   arg3 = (Dali::Vector3 *)jarg3;
30444   if (!arg3) {
30445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30446     return ;
30447   }
30448   {
30449     try {
30450       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30451     } catch (std::out_of_range& e) {
30452       {
30453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30454       };
30455     } catch (std::exception& e) {
30456       {
30457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30458       };
30459     } catch (...) {
30460       {
30461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30462       };
30463     }
30464   }
30465 }
30466
30467
30468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
30469   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30470   Dali::Quaternion *arg2 = 0 ;
30471
30472   arg1 = (Dali::Actor *)jarg1;
30473   arg2 = (Dali::Quaternion *)jarg2;
30474   if (!arg2) {
30475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30476     return ;
30477   }
30478   {
30479     try {
30480       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
30481     } catch (std::out_of_range& e) {
30482       {
30483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30484       };
30485     } catch (std::exception& e) {
30486       {
30487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30488       };
30489     } catch (...) {
30490       {
30491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30492       };
30493     }
30494   }
30495 }
30496
30497
30498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
30499   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30500   Dali::Degree *arg2 = 0 ;
30501   Dali::Vector3 *arg3 = 0 ;
30502
30503   arg1 = (Dali::Actor *)jarg1;
30504   arg2 = (Dali::Degree *)jarg2;
30505   if (!arg2) {
30506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
30507     return ;
30508   }
30509   arg3 = (Dali::Vector3 *)jarg3;
30510   if (!arg3) {
30511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30512     return ;
30513   }
30514   {
30515     try {
30516       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
30517     } catch (std::out_of_range& e) {
30518       {
30519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30520       };
30521     } catch (std::exception& e) {
30522       {
30523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30524       };
30525     } catch (...) {
30526       {
30527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30528       };
30529     }
30530   }
30531 }
30532
30533
30534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
30535   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30536   Dali::Radian *arg2 = 0 ;
30537   Dali::Vector3 *arg3 = 0 ;
30538
30539   arg1 = (Dali::Actor *)jarg1;
30540   arg2 = (Dali::Radian *)jarg2;
30541   if (!arg2) {
30542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
30543     return ;
30544   }
30545   arg3 = (Dali::Vector3 *)jarg3;
30546   if (!arg3) {
30547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30548     return ;
30549   }
30550   {
30551     try {
30552       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
30553     } catch (std::out_of_range& e) {
30554       {
30555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30556       };
30557     } catch (std::exception& e) {
30558       {
30559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30560       };
30561     } catch (...) {
30562       {
30563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30564       };
30565     }
30566   }
30567 }
30568
30569
30570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
30571   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30572   Dali::Quaternion *arg2 = 0 ;
30573
30574   arg1 = (Dali::Actor *)jarg1;
30575   arg2 = (Dali::Quaternion *)jarg2;
30576   if (!arg2) {
30577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
30578     return ;
30579   }
30580   {
30581     try {
30582       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
30583     } catch (std::out_of_range& e) {
30584       {
30585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30586       };
30587     } catch (std::exception& e) {
30588       {
30589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30590       };
30591     } catch (...) {
30592       {
30593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30594       };
30595     }
30596   }
30597 }
30598
30599
30600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
30601   void * jresult ;
30602   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30603   Dali::Quaternion result;
30604
30605   arg1 = (Dali::Actor *)jarg1;
30606   {
30607     try {
30608       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
30609     } catch (std::out_of_range& e) {
30610       {
30611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30612       };
30613     } catch (std::exception& e) {
30614       {
30615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30616       };
30617     } catch (...) {
30618       {
30619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30620       };
30621     }
30622   }
30623   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
30624   return jresult;
30625 }
30626
30627
30628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
30629   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30630   bool arg2 ;
30631
30632   arg1 = (Dali::Actor *)jarg1;
30633   arg2 = jarg2 ? true : false;
30634   {
30635     try {
30636       (arg1)->SetInheritOrientation(arg2);
30637     } catch (std::out_of_range& e) {
30638       {
30639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30640       };
30641     } catch (std::exception& e) {
30642       {
30643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30644       };
30645     } catch (...) {
30646       {
30647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30648       };
30649     }
30650   }
30651 }
30652
30653
30654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
30655   unsigned int jresult ;
30656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30657   bool result;
30658
30659   arg1 = (Dali::Actor *)jarg1;
30660   {
30661     try {
30662       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
30663     } catch (std::out_of_range& e) {
30664       {
30665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30666       };
30667     } catch (std::exception& e) {
30668       {
30669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30670       };
30671     } catch (...) {
30672       {
30673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30674       };
30675     }
30676   }
30677   jresult = result;
30678   return jresult;
30679 }
30680
30681
30682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
30683   void * jresult ;
30684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30685   Dali::Quaternion result;
30686
30687   arg1 = (Dali::Actor *)jarg1;
30688   {
30689     try {
30690       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
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::Quaternion((const Dali::Quaternion &)result);
30706   return jresult;
30707 }
30708
30709
30710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
30711   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30712   float arg2 ;
30713
30714   arg1 = (Dali::Actor *)jarg1;
30715   arg2 = (float)jarg2;
30716   {
30717     try {
30718       (arg1)->SetScale(arg2);
30719     } catch (std::out_of_range& e) {
30720       {
30721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30722       };
30723     } catch (std::exception& e) {
30724       {
30725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30726       };
30727     } catch (...) {
30728       {
30729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30730       };
30731     }
30732   }
30733 }
30734
30735
30736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
30737   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30738   float arg2 ;
30739   float arg3 ;
30740   float arg4 ;
30741
30742   arg1 = (Dali::Actor *)jarg1;
30743   arg2 = (float)jarg2;
30744   arg3 = (float)jarg3;
30745   arg4 = (float)jarg4;
30746   {
30747     try {
30748       (arg1)->SetScale(arg2,arg3,arg4);
30749     } catch (std::out_of_range& e) {
30750       {
30751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30752       };
30753     } catch (std::exception& e) {
30754       {
30755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30756       };
30757     } catch (...) {
30758       {
30759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30760       };
30761     }
30762   }
30763 }
30764
30765
30766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
30767   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30768   Dali::Vector3 *arg2 = 0 ;
30769
30770   arg1 = (Dali::Actor *)jarg1;
30771   arg2 = (Dali::Vector3 *)jarg2;
30772   if (!arg2) {
30773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30774     return ;
30775   }
30776   {
30777     try {
30778       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
30779     } catch (std::out_of_range& e) {
30780       {
30781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30782       };
30783     } catch (std::exception& e) {
30784       {
30785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30786       };
30787     } catch (...) {
30788       {
30789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30790       };
30791     }
30792   }
30793 }
30794
30795
30796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
30797   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30798   Dali::Vector3 *arg2 = 0 ;
30799
30800   arg1 = (Dali::Actor *)jarg1;
30801   arg2 = (Dali::Vector3 *)jarg2;
30802   if (!arg2) {
30803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
30804     return ;
30805   }
30806   {
30807     try {
30808       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
30809     } catch (std::out_of_range& e) {
30810       {
30811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30812       };
30813     } catch (std::exception& e) {
30814       {
30815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30816       };
30817     } catch (...) {
30818       {
30819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30820       };
30821     }
30822   }
30823 }
30824
30825
30826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
30827   void * jresult ;
30828   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30829   Dali::Vector3 result;
30830
30831   arg1 = (Dali::Actor *)jarg1;
30832   {
30833     try {
30834       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
30835     } catch (std::out_of_range& e) {
30836       {
30837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30838       };
30839     } catch (std::exception& e) {
30840       {
30841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30842       };
30843     } catch (...) {
30844       {
30845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30846       };
30847     }
30848   }
30849   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30850   return jresult;
30851 }
30852
30853
30854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
30855   void * jresult ;
30856   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30857   Dali::Vector3 result;
30858
30859   arg1 = (Dali::Actor *)jarg1;
30860   {
30861     try {
30862       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
30863     } catch (std::out_of_range& e) {
30864       {
30865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30866       };
30867     } catch (std::exception& e) {
30868       {
30869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30870       };
30871     } catch (...) {
30872       {
30873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30874       };
30875     }
30876   }
30877   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
30878   return jresult;
30879 }
30880
30881
30882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
30883   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30884   bool arg2 ;
30885
30886   arg1 = (Dali::Actor *)jarg1;
30887   arg2 = jarg2 ? true : false;
30888   {
30889     try {
30890       (arg1)->SetInheritScale(arg2);
30891     } catch (std::out_of_range& e) {
30892       {
30893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30894       };
30895     } catch (std::exception& e) {
30896       {
30897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30898       };
30899     } catch (...) {
30900       {
30901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30902       };
30903     }
30904   }
30905 }
30906
30907
30908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
30909   unsigned int jresult ;
30910   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30911   bool result;
30912
30913   arg1 = (Dali::Actor *)jarg1;
30914   {
30915     try {
30916       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
30917     } catch (std::out_of_range& e) {
30918       {
30919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30920       };
30921     } catch (std::exception& e) {
30922       {
30923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30924       };
30925     } catch (...) {
30926       {
30927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30928       };
30929     }
30930   }
30931   jresult = result;
30932   return jresult;
30933 }
30934
30935
30936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
30937   void * jresult ;
30938   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30939   Dali::Matrix result;
30940
30941   arg1 = (Dali::Actor *)jarg1;
30942   {
30943     try {
30944       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
30945     } catch (std::out_of_range& e) {
30946       {
30947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30948       };
30949     } catch (std::exception& e) {
30950       {
30951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30952       };
30953     } catch (...) {
30954       {
30955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30956       };
30957     }
30958   }
30959   jresult = new Dali::Matrix((const Dali::Matrix &)result);
30960   return jresult;
30961 }
30962
30963
30964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
30965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30966   bool arg2 ;
30967
30968   arg1 = (Dali::Actor *)jarg1;
30969   arg2 = jarg2 ? true : false;
30970   {
30971     try {
30972       (arg1)->SetVisible(arg2);
30973     } catch (std::out_of_range& e) {
30974       {
30975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30976       };
30977     } catch (std::exception& e) {
30978       {
30979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30980       };
30981     } catch (...) {
30982       {
30983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30984       };
30985     }
30986   }
30987 }
30988
30989
30990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
30991   unsigned int jresult ;
30992   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
30993   bool result;
30994
30995   arg1 = (Dali::Actor *)jarg1;
30996   {
30997     try {
30998       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
30999     } catch (std::out_of_range& e) {
31000       {
31001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31002       };
31003     } catch (std::exception& e) {
31004       {
31005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31006       };
31007     } catch (...) {
31008       {
31009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31010       };
31011     }
31012   }
31013   jresult = result;
31014   return jresult;
31015 }
31016
31017
31018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
31019   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31020   float arg2 ;
31021
31022   arg1 = (Dali::Actor *)jarg1;
31023   arg2 = (float)jarg2;
31024   {
31025     try {
31026       (arg1)->SetOpacity(arg2);
31027     } catch (std::out_of_range& e) {
31028       {
31029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31030       };
31031     } catch (std::exception& e) {
31032       {
31033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31034       };
31035     } catch (...) {
31036       {
31037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31038       };
31039     }
31040   }
31041 }
31042
31043
31044 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
31045   float jresult ;
31046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31047   float result;
31048
31049   arg1 = (Dali::Actor *)jarg1;
31050   {
31051     try {
31052       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
31053     } catch (std::out_of_range& e) {
31054       {
31055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31056       };
31057     } catch (std::exception& e) {
31058       {
31059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31060       };
31061     } catch (...) {
31062       {
31063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31064       };
31065     }
31066   }
31067   jresult = result;
31068   return jresult;
31069 }
31070
31071
31072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
31073   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31074   Dali::Vector4 *arg2 = 0 ;
31075
31076   arg1 = (Dali::Actor *)jarg1;
31077   arg2 = (Dali::Vector4 *)jarg2;
31078   if (!arg2) {
31079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
31080     return ;
31081   }
31082   {
31083     try {
31084       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
31085     } catch (std::out_of_range& e) {
31086       {
31087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31088       };
31089     } catch (std::exception& e) {
31090       {
31091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31092       };
31093     } catch (...) {
31094       {
31095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31096       };
31097     }
31098   }
31099 }
31100
31101
31102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
31103   void * jresult ;
31104   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31105   Dali::Vector4 result;
31106
31107   arg1 = (Dali::Actor *)jarg1;
31108   {
31109     try {
31110       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
31111     } catch (std::out_of_range& e) {
31112       {
31113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31114       };
31115     } catch (std::exception& e) {
31116       {
31117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31118       };
31119     } catch (...) {
31120       {
31121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31122       };
31123     }
31124   }
31125   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
31126   return jresult;
31127 }
31128
31129
31130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
31131   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31132   Dali::ColorMode arg2 ;
31133
31134   arg1 = (Dali::Actor *)jarg1;
31135   arg2 = (Dali::ColorMode)jarg2;
31136   {
31137     try {
31138       (arg1)->SetColorMode(arg2);
31139     } catch (std::out_of_range& e) {
31140       {
31141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31142       };
31143     } catch (std::exception& e) {
31144       {
31145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31146       };
31147     } catch (...) {
31148       {
31149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31150       };
31151     }
31152   }
31153 }
31154
31155
31156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
31157   int jresult ;
31158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31159   Dali::ColorMode result;
31160
31161   arg1 = (Dali::Actor *)jarg1;
31162   {
31163     try {
31164       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
31165     } catch (std::out_of_range& e) {
31166       {
31167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31168       };
31169     } catch (std::exception& e) {
31170       {
31171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31172       };
31173     } catch (...) {
31174       {
31175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31176       };
31177     }
31178   }
31179   jresult = (int)result;
31180   return jresult;
31181 }
31182
31183
31184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
31185   void * jresult ;
31186   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31187   Dali::Vector4 result;
31188
31189   arg1 = (Dali::Actor *)jarg1;
31190   {
31191     try {
31192       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
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 = new Dali::Vector4((const Dali::Vector4 &)result);
31208   return jresult;
31209 }
31210
31211
31212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
31213   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31214   Dali::DrawMode::Type arg2 ;
31215
31216   arg1 = (Dali::Actor *)jarg1;
31217   arg2 = (Dali::DrawMode::Type)jarg2;
31218   {
31219     try {
31220       (arg1)->SetDrawMode(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 int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
31239   int jresult ;
31240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31241   Dali::DrawMode::Type result;
31242
31243   arg1 = (Dali::Actor *)jarg1;
31244   {
31245     try {
31246       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
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 = (int)result;
31262   return jresult;
31263 }
31264
31265
31266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(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)->SetSensitive(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_IsSensitive(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)->IsSensitive();
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 unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
31321   unsigned int jresult ;
31322   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31323   float *arg2 = 0 ;
31324   float *arg3 = 0 ;
31325   float arg4 ;
31326   float arg5 ;
31327   bool result;
31328
31329   arg1 = (Dali::Actor *)jarg1;
31330   arg2 = (float *)jarg2;
31331   arg3 = (float *)jarg3;
31332   arg4 = (float)jarg4;
31333   arg5 = (float)jarg5;
31334   {
31335     try {
31336       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
31337     } catch (std::out_of_range& e) {
31338       {
31339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31340       };
31341     } catch (std::exception& e) {
31342       {
31343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31344       };
31345     } catch (...) {
31346       {
31347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31348       };
31349     }
31350   }
31351   jresult = result;
31352   return jresult;
31353 }
31354
31355
31356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
31357   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31358   bool arg2 ;
31359
31360   arg1 = (Dali::Actor *)jarg1;
31361   arg2 = jarg2 ? true : false;
31362   {
31363     try {
31364       (arg1)->SetLeaveRequired(arg2);
31365     } catch (std::out_of_range& e) {
31366       {
31367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31368       };
31369     } catch (std::exception& e) {
31370       {
31371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31372       };
31373     } catch (...) {
31374       {
31375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31376       };
31377     }
31378   }
31379 }
31380
31381
31382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
31383   unsigned int jresult ;
31384   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31385   bool result;
31386
31387   arg1 = (Dali::Actor *)jarg1;
31388   {
31389     try {
31390       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
31391     } catch (std::out_of_range& e) {
31392       {
31393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31394       };
31395     } catch (std::exception& e) {
31396       {
31397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31398       };
31399     } catch (...) {
31400       {
31401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31402       };
31403     }
31404   }
31405   jresult = result;
31406   return jresult;
31407 }
31408
31409
31410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
31411   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31412   bool arg2 ;
31413
31414   arg1 = (Dali::Actor *)jarg1;
31415   arg2 = jarg2 ? true : false;
31416   {
31417     try {
31418       (arg1)->SetKeyboardFocusable(arg2);
31419     } catch (std::out_of_range& e) {
31420       {
31421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31422       };
31423     } catch (std::exception& e) {
31424       {
31425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31426       };
31427     } catch (...) {
31428       {
31429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31430       };
31431     }
31432   }
31433 }
31434
31435
31436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
31437   unsigned int jresult ;
31438   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31439   bool result;
31440
31441   arg1 = (Dali::Actor *)jarg1;
31442   {
31443     try {
31444       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
31445     } catch (std::out_of_range& e) {
31446       {
31447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31448       };
31449     } catch (std::exception& e) {
31450       {
31451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31452       };
31453     } catch (...) {
31454       {
31455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31456       };
31457     }
31458   }
31459   jresult = result;
31460   return jresult;
31461 }
31462
31463
31464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
31465   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31466   Dali::ResizePolicy::Type arg2 ;
31467   Dali::Dimension::Type arg3 ;
31468
31469   arg1 = (Dali::Actor *)jarg1;
31470   arg2 = (Dali::ResizePolicy::Type)jarg2;
31471   arg3 = (Dali::Dimension::Type)jarg3;
31472   {
31473     try {
31474       (arg1)->SetResizePolicy(arg2,arg3);
31475     } catch (std::out_of_range& e) {
31476       {
31477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31478       };
31479     } catch (std::exception& e) {
31480       {
31481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31482       };
31483     } catch (...) {
31484       {
31485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31486       };
31487     }
31488   }
31489 }
31490
31491
31492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
31493   int jresult ;
31494   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31495   Dali::Dimension::Type arg2 ;
31496   Dali::ResizePolicy::Type result;
31497
31498   arg1 = (Dali::Actor *)jarg1;
31499   arg2 = (Dali::Dimension::Type)jarg2;
31500   {
31501     try {
31502       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
31503     } catch (std::out_of_range& e) {
31504       {
31505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31506       };
31507     } catch (std::exception& e) {
31508       {
31509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31510       };
31511     } catch (...) {
31512       {
31513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31514       };
31515     }
31516   }
31517   jresult = (int)result;
31518   return jresult;
31519 }
31520
31521
31522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
31523   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31524   Dali::SizeScalePolicy::Type arg2 ;
31525
31526   arg1 = (Dali::Actor *)jarg1;
31527   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
31528   {
31529     try {
31530       (arg1)->SetSizeScalePolicy(arg2);
31531     } catch (std::out_of_range& e) {
31532       {
31533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31534       };
31535     } catch (std::exception& e) {
31536       {
31537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31538       };
31539     } catch (...) {
31540       {
31541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31542       };
31543     }
31544   }
31545 }
31546
31547
31548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
31549   int jresult ;
31550   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31551   Dali::SizeScalePolicy::Type result;
31552
31553   arg1 = (Dali::Actor *)jarg1;
31554   {
31555     try {
31556       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
31557     } catch (std::out_of_range& e) {
31558       {
31559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31560       };
31561     } catch (std::exception& e) {
31562       {
31563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31564       };
31565     } catch (...) {
31566       {
31567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31568       };
31569     }
31570   }
31571   jresult = (int)result;
31572   return jresult;
31573 }
31574
31575
31576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
31577   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31578   Dali::Vector3 *arg2 = 0 ;
31579
31580   arg1 = (Dali::Actor *)jarg1;
31581   arg2 = (Dali::Vector3 *)jarg2;
31582   if (!arg2) {
31583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
31584     return ;
31585   }
31586   {
31587     try {
31588       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
31589     } catch (std::out_of_range& e) {
31590       {
31591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31592       };
31593     } catch (std::exception& e) {
31594       {
31595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31596       };
31597     } catch (...) {
31598       {
31599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31600       };
31601     }
31602   }
31603 }
31604
31605
31606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
31607   void * jresult ;
31608   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31609   Dali::Vector3 result;
31610
31611   arg1 = (Dali::Actor *)jarg1;
31612   {
31613     try {
31614       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
31615     } catch (std::out_of_range& e) {
31616       {
31617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31618       };
31619     } catch (std::exception& e) {
31620       {
31621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31622       };
31623     } catch (...) {
31624       {
31625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31626       };
31627     }
31628   }
31629   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
31630   return jresult;
31631 }
31632
31633
31634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
31635   float jresult ;
31636   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31637   float arg2 ;
31638   float result;
31639
31640   arg1 = (Dali::Actor *)jarg1;
31641   arg2 = (float)jarg2;
31642   {
31643     try {
31644       result = (float)(arg1)->GetHeightForWidth(arg2);
31645     } catch (std::out_of_range& e) {
31646       {
31647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31648       };
31649     } catch (std::exception& e) {
31650       {
31651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31652       };
31653     } catch (...) {
31654       {
31655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31656       };
31657     }
31658   }
31659   jresult = result;
31660   return jresult;
31661 }
31662
31663
31664 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
31665   float jresult ;
31666   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31667   float arg2 ;
31668   float result;
31669
31670   arg1 = (Dali::Actor *)jarg1;
31671   arg2 = (float)jarg2;
31672   {
31673     try {
31674       result = (float)(arg1)->GetWidthForHeight(arg2);
31675     } catch (std::out_of_range& e) {
31676       {
31677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31678       };
31679     } catch (std::exception& e) {
31680       {
31681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31682       };
31683     } catch (...) {
31684       {
31685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31686       };
31687     }
31688   }
31689   jresult = result;
31690   return jresult;
31691 }
31692
31693
31694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
31695   float jresult ;
31696   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31697   Dali::Dimension::Type arg2 ;
31698   float result;
31699
31700   arg1 = (Dali::Actor *)jarg1;
31701   arg2 = (Dali::Dimension::Type)jarg2;
31702   {
31703     try {
31704       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
31705     } catch (std::out_of_range& e) {
31706       {
31707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31708       };
31709     } catch (std::exception& e) {
31710       {
31711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31712       };
31713     } catch (...) {
31714       {
31715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31716       };
31717     }
31718   }
31719   jresult = result;
31720   return jresult;
31721 }
31722
31723
31724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
31725   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31726   Dali::Padding *arg2 = 0 ;
31727
31728   arg1 = (Dali::Actor *)jarg1;
31729   arg2 = (Dali::Padding *)jarg2;
31730   if (!arg2) {
31731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
31732     return ;
31733   }
31734   {
31735     try {
31736       (arg1)->SetPadding((Dali::Padding const &)*arg2);
31737     } catch (std::out_of_range& e) {
31738       {
31739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31740       };
31741     } catch (std::exception& e) {
31742       {
31743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31744       };
31745     } catch (...) {
31746       {
31747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31748       };
31749     }
31750   }
31751 }
31752
31753
31754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
31755   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31756   Dali::Padding *arg2 = 0 ;
31757
31758   arg1 = (Dali::Actor *)jarg1;
31759   arg2 = (Dali::Padding *)jarg2;
31760   if (!arg2) {
31761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
31762     return ;
31763   }
31764   {
31765     try {
31766       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
31767     } catch (std::out_of_range& e) {
31768       {
31769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31770       };
31771     } catch (std::exception& e) {
31772       {
31773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31774       };
31775     } catch (...) {
31776       {
31777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31778       };
31779     }
31780   }
31781 }
31782
31783
31784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
31785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31786   Dali::Vector2 *arg2 = 0 ;
31787
31788   arg1 = (Dali::Actor *)jarg1;
31789   arg2 = (Dali::Vector2 *)jarg2;
31790   if (!arg2) {
31791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31792     return ;
31793   }
31794   {
31795     try {
31796       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
31797     } catch (std::out_of_range& e) {
31798       {
31799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31800       };
31801     } catch (std::exception& e) {
31802       {
31803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31804       };
31805     } catch (...) {
31806       {
31807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31808       };
31809     }
31810   }
31811 }
31812
31813
31814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
31815   void * jresult ;
31816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31817   Dali::Vector2 result;
31818
31819   arg1 = (Dali::Actor *)jarg1;
31820   {
31821     try {
31822       result = (arg1)->GetMinimumSize();
31823     } catch (std::out_of_range& e) {
31824       {
31825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31826       };
31827     } catch (std::exception& e) {
31828       {
31829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31830       };
31831     } catch (...) {
31832       {
31833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31834       };
31835     }
31836   }
31837   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31838   return jresult;
31839 }
31840
31841
31842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
31843   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31844   Dali::Vector2 *arg2 = 0 ;
31845
31846   arg1 = (Dali::Actor *)jarg1;
31847   arg2 = (Dali::Vector2 *)jarg2;
31848   if (!arg2) {
31849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
31850     return ;
31851   }
31852   {
31853     try {
31854       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
31855     } catch (std::out_of_range& e) {
31856       {
31857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31858       };
31859     } catch (std::exception& e) {
31860       {
31861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31862       };
31863     } catch (...) {
31864       {
31865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31866       };
31867     }
31868   }
31869 }
31870
31871
31872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
31873   void * jresult ;
31874   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31875   Dali::Vector2 result;
31876
31877   arg1 = (Dali::Actor *)jarg1;
31878   {
31879     try {
31880       result = (arg1)->GetMaximumSize();
31881     } catch (std::out_of_range& e) {
31882       {
31883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31884       };
31885     } catch (std::exception& e) {
31886       {
31887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31888       };
31889     } catch (...) {
31890       {
31891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31892       };
31893     }
31894   }
31895   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
31896   return jresult;
31897 }
31898
31899
31900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
31901   int jresult ;
31902   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31903   int result;
31904
31905   arg1 = (Dali::Actor *)jarg1;
31906   {
31907     try {
31908       result = (int)(arg1)->GetHierarchyDepth();
31909     } catch (std::out_of_range& e) {
31910       {
31911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31912       };
31913     } catch (std::exception& e) {
31914       {
31915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31916       };
31917     } catch (...) {
31918       {
31919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31920       };
31921     }
31922   }
31923   jresult = result;
31924   return jresult;
31925 }
31926
31927
31928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
31929   unsigned int jresult ;
31930   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31931   Dali::Renderer *arg2 = 0 ;
31932   unsigned int result;
31933
31934   arg1 = (Dali::Actor *)jarg1;
31935   arg2 = (Dali::Renderer *)jarg2;
31936   if (!arg2) {
31937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
31938     return 0;
31939   }
31940   {
31941     try {
31942       result = (unsigned int)(arg1)->AddRenderer(*arg2);
31943     } catch (std::out_of_range& e) {
31944       {
31945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31946       };
31947     } catch (std::exception& e) {
31948       {
31949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31950       };
31951     } catch (...) {
31952       {
31953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31954       };
31955     }
31956   }
31957   jresult = result;
31958   return jresult;
31959 }
31960
31961
31962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
31963   unsigned int jresult ;
31964   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31965   unsigned int result;
31966
31967   arg1 = (Dali::Actor *)jarg1;
31968   {
31969     try {
31970       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
31971     } catch (std::out_of_range& e) {
31972       {
31973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31974       };
31975     } catch (std::exception& e) {
31976       {
31977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31978       };
31979     } catch (...) {
31980       {
31981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31982       };
31983     }
31984   }
31985   jresult = result;
31986   return jresult;
31987 }
31988
31989
31990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
31991   void * jresult ;
31992   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
31993   unsigned int arg2 ;
31994   Dali::Renderer result;
31995
31996   arg1 = (Dali::Actor *)jarg1;
31997   arg2 = (unsigned int)jarg2;
31998   {
31999     try {
32000       result = (arg1)->GetRendererAt(arg2);
32001     } catch (std::out_of_range& e) {
32002       {
32003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32004       };
32005     } catch (std::exception& e) {
32006       {
32007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32008       };
32009     } catch (...) {
32010       {
32011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32012       };
32013     }
32014   }
32015   jresult = new Dali::Renderer((const Dali::Renderer &)result);
32016   return jresult;
32017 }
32018
32019
32020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
32021   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32022   Dali::Renderer *arg2 = 0 ;
32023
32024   arg1 = (Dali::Actor *)jarg1;
32025   arg2 = (Dali::Renderer *)jarg2;
32026   if (!arg2) {
32027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
32028     return ;
32029   }
32030   {
32031     try {
32032       (arg1)->RemoveRenderer(*arg2);
32033     } catch (std::out_of_range& e) {
32034       {
32035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32036       };
32037     } catch (std::exception& e) {
32038       {
32039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32040       };
32041     } catch (...) {
32042       {
32043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32044       };
32045     }
32046   }
32047 }
32048
32049
32050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
32051   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32052   unsigned int arg2 ;
32053
32054   arg1 = (Dali::Actor *)jarg1;
32055   arg2 = (unsigned int)jarg2;
32056   {
32057     try {
32058       (arg1)->RemoveRenderer(arg2);
32059     } catch (std::out_of_range& e) {
32060       {
32061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32062       };
32063     } catch (std::exception& e) {
32064       {
32065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32066       };
32067     } catch (...) {
32068       {
32069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32070       };
32071     }
32072   }
32073 }
32074
32075
32076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
32077   void * jresult ;
32078   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32079   Dali::Actor::TouchSignalType *result = 0 ;
32080
32081   arg1 = (Dali::Actor *)jarg1;
32082   {
32083     try {
32084       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
32085     } catch (std::out_of_range& e) {
32086       {
32087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32088       };
32089     } catch (std::exception& e) {
32090       {
32091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32092       };
32093     } catch (...) {
32094       {
32095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32096       };
32097     }
32098   }
32099   jresult = (void *)result;
32100   return jresult;
32101 }
32102
32103
32104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
32105   void * jresult ;
32106   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32107   Dali::Actor::TouchDataSignalType *result = 0 ;
32108
32109   arg1 = (Dali::Actor *)jarg1;
32110   {
32111     try {
32112       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
32113     } catch (std::out_of_range& e) {
32114       {
32115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32116       };
32117     } catch (std::exception& e) {
32118       {
32119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32120       };
32121     } catch (...) {
32122       {
32123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32124       };
32125     }
32126   }
32127   jresult = (void *)result;
32128   return jresult;
32129 }
32130
32131
32132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
32133   void * jresult ;
32134   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32135   Dali::Actor::HoverSignalType *result = 0 ;
32136
32137   arg1 = (Dali::Actor *)jarg1;
32138   {
32139     try {
32140       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
32141     } catch (std::out_of_range& e) {
32142       {
32143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32144       };
32145     } catch (std::exception& e) {
32146       {
32147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32148       };
32149     } catch (...) {
32150       {
32151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32152       };
32153     }
32154   }
32155   jresult = (void *)result;
32156   return jresult;
32157 }
32158
32159
32160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
32161   void * jresult ;
32162   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32163   Dali::Actor::WheelEventSignalType *result = 0 ;
32164
32165   arg1 = (Dali::Actor *)jarg1;
32166   {
32167     try {
32168       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
32169     } catch (std::out_of_range& e) {
32170       {
32171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32172       };
32173     } catch (std::exception& e) {
32174       {
32175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32176       };
32177     } catch (...) {
32178       {
32179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32180       };
32181     }
32182   }
32183   jresult = (void *)result;
32184   return jresult;
32185 }
32186
32187
32188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
32189   void * jresult ;
32190   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32191   Dali::Actor::OnStageSignalType *result = 0 ;
32192
32193   arg1 = (Dali::Actor *)jarg1;
32194   {
32195     try {
32196       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
32197     } catch (std::out_of_range& e) {
32198       {
32199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32200       };
32201     } catch (std::exception& e) {
32202       {
32203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32204       };
32205     } catch (...) {
32206       {
32207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32208       };
32209     }
32210   }
32211   jresult = (void *)result;
32212   return jresult;
32213 }
32214
32215
32216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
32217   void * jresult ;
32218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32219   Dali::Actor::OffStageSignalType *result = 0 ;
32220
32221   arg1 = (Dali::Actor *)jarg1;
32222   {
32223     try {
32224       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
32225     } catch (std::out_of_range& e) {
32226       {
32227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32228       };
32229     } catch (std::exception& e) {
32230       {
32231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32232       };
32233     } catch (...) {
32234       {
32235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32236       };
32237     }
32238   }
32239   jresult = (void *)result;
32240   return jresult;
32241 }
32242
32243
32244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
32245   void * jresult ;
32246   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
32247   Dali::Actor::OnRelayoutSignalType *result = 0 ;
32248
32249   arg1 = (Dali::Actor *)jarg1;
32250   {
32251     try {
32252       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
32253     } catch (std::out_of_range& e) {
32254       {
32255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32256       };
32257     } catch (std::exception& e) {
32258       {
32259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32260       };
32261     } catch (...) {
32262       {
32263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32264       };
32265     }
32266   }
32267   jresult = (void *)result;
32268   return jresult;
32269 }
32270
32271
32272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
32273   Dali::Actor *arg1 = 0 ;
32274
32275   arg1 = (Dali::Actor *)jarg1;
32276   if (!arg1) {
32277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
32278     return ;
32279   }
32280   {
32281     try {
32282       Dali::UnparentAndReset(*arg1);
32283     } catch (std::out_of_range& e) {
32284       {
32285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32286       };
32287     } catch (std::exception& e) {
32288       {
32289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32290       };
32291     } catch (...) {
32292       {
32293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32294       };
32295     }
32296   }
32297 }
32298
32299
32300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32301   Dali::Actor arg1 ;
32302   Dali::Actor *argp1 ;
32303
32304   argp1 = (Dali::Actor *)jarg1;
32305   if (!argp1) {
32306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32307     return ;
32308   }
32309   arg1 = *argp1;
32310   {
32311     try {
32312       Dali::DevelActor::Raise(arg1);
32313     } catch (std::out_of_range& e) {
32314       {
32315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32316       };
32317     } catch (std::exception& e) {
32318       {
32319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32320       };
32321     } catch (...) {
32322       {
32323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32324       };
32325     }
32326   }
32327 }
32328
32329
32330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32331   Dali::Actor arg1 ;
32332   Dali::Actor *argp1 ;
32333
32334   argp1 = (Dali::Actor *)jarg1;
32335   if (!argp1) {
32336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32337     return ;
32338   }
32339   arg1 = *argp1;
32340   {
32341     try {
32342       Dali::DevelActor::Lower(arg1);
32343     } catch (std::out_of_range& e) {
32344       {
32345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32346       };
32347     } catch (std::exception& e) {
32348       {
32349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32350       };
32351     } catch (...) {
32352       {
32353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32354       };
32355     }
32356   }
32357 }
32358
32359
32360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32361   Dali::Actor arg1 ;
32362   Dali::Actor *argp1 ;
32363
32364   argp1 = (Dali::Actor *)jarg1;
32365   if (!argp1) {
32366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32367     return ;
32368   }
32369   arg1 = *argp1;
32370   {
32371     try {
32372       Dali::DevelActor::RaiseToTop(arg1);
32373     } catch (std::out_of_range& e) {
32374       {
32375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32376       };
32377     } catch (std::exception& e) {
32378       {
32379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32380       };
32381     } catch (...) {
32382       {
32383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32384       };
32385     }
32386   }
32387 }
32388
32389
32390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32391   Dali::Actor arg1 ;
32392   Dali::Actor *argp1 ;
32393
32394   argp1 = (Dali::Actor *)jarg1;
32395   if (!argp1) {
32396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32397     return ;
32398   }
32399   arg1 = *argp1;
32400   {
32401     try {
32402       Dali::DevelActor::LowerToBottom(arg1);
32403     } catch (std::out_of_range& e) {
32404       {
32405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32406       };
32407     } catch (std::exception& e) {
32408       {
32409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32410       };
32411     } catch (...) {
32412       {
32413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32414       };
32415     }
32416   }
32417 }
32418
32419
32420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32421   Dali::Actor arg1 ;
32422   Dali::Actor arg2 ;
32423   Dali::Actor *argp1 ;
32424   Dali::Actor *argp2 ;
32425
32426   argp1 = (Dali::Actor *)jarg1;
32427   if (!argp1) {
32428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32429     return ;
32430   }
32431   arg1 = *argp1;
32432   argp2 = (Dali::Actor *)jarg2;
32433   if (!argp2) {
32434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32435     return ;
32436   }
32437   arg2 = *argp2;
32438   {
32439     try {
32440       Dali::DevelActor::RaiseAbove(arg1,arg2);
32441     } catch (std::out_of_range& e) {
32442       {
32443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32444       };
32445     } catch (std::exception& e) {
32446       {
32447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32448       };
32449     } catch (...) {
32450       {
32451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32452       };
32453     }
32454   }
32455 }
32456
32457
32458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32459   Dali::Actor arg1 ;
32460   Dali::Actor arg2 ;
32461   Dali::Actor *argp1 ;
32462   Dali::Actor *argp2 ;
32463
32464   argp1 = (Dali::Actor *)jarg1;
32465   if (!argp1) {
32466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32467     return ;
32468   }
32469   arg1 = *argp1;
32470   argp2 = (Dali::Actor *)jarg2;
32471   if (!argp2) {
32472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32473     return ;
32474   }
32475   arg2 = *argp2;
32476   {
32477     try {
32478       Dali::DevelActor::LowerBelow(arg1,arg2);
32479     } catch (std::out_of_range& e) {
32480       {
32481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32482       };
32483     } catch (std::exception& e) {
32484       {
32485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32486       };
32487     } catch (...) {
32488       {
32489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32490       };
32491     }
32492   }
32493 }
32494
32495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32496   void * jresult ;
32497   Dali::Actor arg1 ;
32498   Dali::Actor *argp1 ;
32499   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32500
32501   argp1 = (Dali::Actor *)jarg1;
32502   if (!argp1) {
32503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32504     return 0;
32505   }
32506   arg1 = *argp1;
32507   {
32508     try {
32509       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32510     } catch (std::out_of_range& e) {
32511       {
32512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32513       };
32514     } catch (std::exception& e) {
32515       {
32516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32517       };
32518     } catch (...) {
32519       {
32520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32521       };
32522     }
32523   }
32524   jresult = (void *)result;
32525   return jresult;
32526 }
32527
32528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
32529   int jresult ;
32530   int result;
32531
32532   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
32533   jresult = (int)result;
32534   return jresult;
32535 }
32536
32537
32538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
32539   int jresult ;
32540   int result;
32541
32542   result = (int)Dali::Layer::Property::CLIPPING_BOX;
32543   jresult = (int)result;
32544   return jresult;
32545 }
32546
32547
32548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
32549   int jresult ;
32550   int result;
32551
32552   result = (int)Dali::Layer::Property::BEHAVIOR;
32553   jresult = (int)result;
32554   return jresult;
32555 }
32556
32557
32558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
32559   void * jresult ;
32560   Dali::Layer::Property *result = 0 ;
32561
32562   {
32563     try {
32564       result = (Dali::Layer::Property *)new Dali::Layer::Property();
32565     } catch (std::out_of_range& e) {
32566       {
32567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32568       };
32569     } catch (std::exception& e) {
32570       {
32571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32572       };
32573     } catch (...) {
32574       {
32575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32576       };
32577     }
32578   }
32579   jresult = (void *)result;
32580   return jresult;
32581 }
32582
32583
32584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
32585   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
32586
32587   arg1 = (Dali::Layer::Property *)jarg1;
32588   {
32589     try {
32590       delete arg1;
32591     } catch (std::out_of_range& e) {
32592       {
32593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32594       };
32595     } catch (std::exception& e) {
32596       {
32597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32598       };
32599     } catch (...) {
32600       {
32601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32602       };
32603     }
32604   }
32605 }
32606
32607
32608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
32609   void * jresult ;
32610   Dali::Layer *result = 0 ;
32611
32612   {
32613     try {
32614       result = (Dali::Layer *)new Dali::Layer();
32615     } catch (std::out_of_range& e) {
32616       {
32617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32618       };
32619     } catch (std::exception& e) {
32620       {
32621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32622       };
32623     } catch (...) {
32624       {
32625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32626       };
32627     }
32628   }
32629   jresult = (void *)result;
32630   return jresult;
32631 }
32632
32633
32634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
32635   void * jresult ;
32636   Dali::Layer result;
32637
32638   {
32639     try {
32640       result = Dali::Layer::New();
32641     } catch (std::out_of_range& e) {
32642       {
32643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32644       };
32645     } catch (std::exception& e) {
32646       {
32647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32648       };
32649     } catch (...) {
32650       {
32651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32652       };
32653     }
32654   }
32655   jresult = new Dali::Layer((const Dali::Layer &)result);
32656   return jresult;
32657 }
32658
32659
32660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
32661   void * jresult ;
32662   Dali::BaseHandle arg1 ;
32663   Dali::BaseHandle *argp1 ;
32664   Dali::Layer result;
32665
32666   argp1 = (Dali::BaseHandle *)jarg1;
32667   if (!argp1) {
32668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
32669     return 0;
32670   }
32671   arg1 = *argp1;
32672   {
32673     try {
32674       result = Dali::Layer::DownCast(arg1);
32675     } catch (std::out_of_range& e) {
32676       {
32677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32678       };
32679     } catch (std::exception& e) {
32680       {
32681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32682       };
32683     } catch (...) {
32684       {
32685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32686       };
32687     }
32688   }
32689   jresult = new Dali::Layer((const Dali::Layer &)result);
32690   return jresult;
32691 }
32692
32693
32694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
32695   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32696
32697   arg1 = (Dali::Layer *)jarg1;
32698   {
32699     try {
32700       delete arg1;
32701     } catch (std::out_of_range& e) {
32702       {
32703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32704       };
32705     } catch (std::exception& e) {
32706       {
32707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32708       };
32709     } catch (...) {
32710       {
32711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32712       };
32713     }
32714   }
32715 }
32716
32717
32718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
32719   void * jresult ;
32720   Dali::Layer *arg1 = 0 ;
32721   Dali::Layer *result = 0 ;
32722
32723   arg1 = (Dali::Layer *)jarg1;
32724   if (!arg1) {
32725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32726     return 0;
32727   }
32728   {
32729     try {
32730       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
32731     } catch (std::out_of_range& e) {
32732       {
32733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32734       };
32735     } catch (std::exception& e) {
32736       {
32737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32738       };
32739     } catch (...) {
32740       {
32741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32742       };
32743     }
32744   }
32745   jresult = (void *)result;
32746   return jresult;
32747 }
32748
32749
32750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
32751   void * jresult ;
32752   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32753   Dali::Layer *arg2 = 0 ;
32754   Dali::Layer *result = 0 ;
32755
32756   arg1 = (Dali::Layer *)jarg1;
32757   arg2 = (Dali::Layer *)jarg2;
32758   if (!arg2) {
32759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
32760     return 0;
32761   }
32762   {
32763     try {
32764       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
32765     } catch (std::out_of_range& e) {
32766       {
32767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32768       };
32769     } catch (std::exception& e) {
32770       {
32771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32772       };
32773     } catch (...) {
32774       {
32775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32776       };
32777     }
32778   }
32779   jresult = (void *)result;
32780   return jresult;
32781 }
32782
32783
32784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
32785   unsigned int jresult ;
32786   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32787   unsigned int result;
32788
32789   arg1 = (Dali::Layer *)jarg1;
32790   {
32791     try {
32792       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
32793     } catch (std::out_of_range& e) {
32794       {
32795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32796       };
32797     } catch (std::exception& e) {
32798       {
32799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32800       };
32801     } catch (...) {
32802       {
32803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32804       };
32805     }
32806   }
32807   jresult = result;
32808   return jresult;
32809 }
32810
32811
32812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
32813   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32814
32815   arg1 = (Dali::Layer *)jarg1;
32816   {
32817     try {
32818       (arg1)->Raise();
32819     } catch (std::out_of_range& e) {
32820       {
32821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32822       };
32823     } catch (std::exception& e) {
32824       {
32825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32826       };
32827     } catch (...) {
32828       {
32829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32830       };
32831     }
32832   }
32833 }
32834
32835
32836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
32837   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32838
32839   arg1 = (Dali::Layer *)jarg1;
32840   {
32841     try {
32842       (arg1)->Lower();
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_RaiseAbove(void * jarg1, void * jarg2) {
32861   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32862   Dali::Layer arg2 ;
32863   Dali::Layer *argp2 ;
32864
32865   arg1 = (Dali::Layer *)jarg1;
32866   argp2 = (Dali::Layer *)jarg2;
32867   if (!argp2) {
32868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32869     return ;
32870   }
32871   arg2 = *argp2;
32872   {
32873     try {
32874       (arg1)->RaiseAbove(arg2);
32875     } catch (std::out_of_range& e) {
32876       {
32877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32878       };
32879     } catch (std::exception& e) {
32880       {
32881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32882       };
32883     } catch (...) {
32884       {
32885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32886       };
32887     }
32888   }
32889 }
32890
32891
32892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
32893   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32894   Dali::Layer arg2 ;
32895   Dali::Layer *argp2 ;
32896
32897   arg1 = (Dali::Layer *)jarg1;
32898   argp2 = (Dali::Layer *)jarg2;
32899   if (!argp2) {
32900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32901     return ;
32902   }
32903   arg2 = *argp2;
32904   {
32905     try {
32906       (arg1)->LowerBelow(arg2);
32907     } catch (std::out_of_range& e) {
32908       {
32909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32910       };
32911     } catch (std::exception& e) {
32912       {
32913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32914       };
32915     } catch (...) {
32916       {
32917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32918       };
32919     }
32920   }
32921 }
32922
32923
32924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
32925   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32926
32927   arg1 = (Dali::Layer *)jarg1;
32928   {
32929     try {
32930       (arg1)->RaiseToTop();
32931     } catch (std::out_of_range& e) {
32932       {
32933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32934       };
32935     } catch (std::exception& e) {
32936       {
32937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32938       };
32939     } catch (...) {
32940       {
32941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32942       };
32943     }
32944   }
32945 }
32946
32947
32948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
32949   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32950
32951   arg1 = (Dali::Layer *)jarg1;
32952   {
32953     try {
32954       (arg1)->LowerToBottom();
32955     } catch (std::out_of_range& e) {
32956       {
32957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32958       };
32959     } catch (std::exception& e) {
32960       {
32961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32962       };
32963     } catch (...) {
32964       {
32965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32966       };
32967     }
32968   }
32969 }
32970
32971
32972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
32973   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
32974   Dali::Layer arg2 ;
32975   Dali::Layer *argp2 ;
32976
32977   arg1 = (Dali::Layer *)jarg1;
32978   argp2 = (Dali::Layer *)jarg2;
32979   if (!argp2) {
32980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
32981     return ;
32982   }
32983   arg2 = *argp2;
32984   {
32985     try {
32986       (arg1)->MoveAbove(arg2);
32987     } catch (std::out_of_range& e) {
32988       {
32989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32990       };
32991     } catch (std::exception& e) {
32992       {
32993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32994       };
32995     } catch (...) {
32996       {
32997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32998       };
32999     }
33000   }
33001 }
33002
33003
33004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
33005   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33006   Dali::Layer arg2 ;
33007   Dali::Layer *argp2 ;
33008
33009   arg1 = (Dali::Layer *)jarg1;
33010   argp2 = (Dali::Layer *)jarg2;
33011   if (!argp2) {
33012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
33013     return ;
33014   }
33015   arg2 = *argp2;
33016   {
33017     try {
33018       (arg1)->MoveBelow(arg2);
33019     } catch (std::out_of_range& e) {
33020       {
33021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33022       };
33023     } catch (std::exception& e) {
33024       {
33025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33026       };
33027     } catch (...) {
33028       {
33029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33030       };
33031     }
33032   }
33033 }
33034
33035
33036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
33037   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33038   Dali::Layer::Behavior arg2 ;
33039
33040   arg1 = (Dali::Layer *)jarg1;
33041   arg2 = (Dali::Layer::Behavior)jarg2;
33042   {
33043     try {
33044       (arg1)->SetBehavior(arg2);
33045     } catch (std::out_of_range& e) {
33046       {
33047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33048       };
33049     } catch (std::exception& e) {
33050       {
33051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33052       };
33053     } catch (...) {
33054       {
33055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33056       };
33057     }
33058   }
33059 }
33060
33061
33062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
33063   int jresult ;
33064   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33065   Dali::Layer::Behavior result;
33066
33067   arg1 = (Dali::Layer *)jarg1;
33068   {
33069     try {
33070       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
33071     } catch (std::out_of_range& e) {
33072       {
33073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33074       };
33075     } catch (std::exception& e) {
33076       {
33077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33078       };
33079     } catch (...) {
33080       {
33081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33082       };
33083     }
33084   }
33085   jresult = (int)result;
33086   return jresult;
33087 }
33088
33089
33090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
33091   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33092   bool arg2 ;
33093
33094   arg1 = (Dali::Layer *)jarg1;
33095   arg2 = jarg2 ? true : false;
33096   {
33097     try {
33098       (arg1)->SetClipping(arg2);
33099     } catch (std::out_of_range& e) {
33100       {
33101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33102       };
33103     } catch (std::exception& e) {
33104       {
33105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33106       };
33107     } catch (...) {
33108       {
33109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33110       };
33111     }
33112   }
33113 }
33114
33115
33116 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
33117   unsigned int jresult ;
33118   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33119   bool result;
33120
33121   arg1 = (Dali::Layer *)jarg1;
33122   {
33123     try {
33124       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
33125     } catch (std::out_of_range& e) {
33126       {
33127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33128       };
33129     } catch (std::exception& e) {
33130       {
33131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33132       };
33133     } catch (...) {
33134       {
33135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33136       };
33137     }
33138   }
33139   jresult = result;
33140   return jresult;
33141 }
33142
33143
33144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
33145   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33146   int arg2 ;
33147   int arg3 ;
33148   int arg4 ;
33149   int arg5 ;
33150
33151   arg1 = (Dali::Layer *)jarg1;
33152   arg2 = (int)jarg2;
33153   arg3 = (int)jarg3;
33154   arg4 = (int)jarg4;
33155   arg5 = (int)jarg5;
33156   {
33157     try {
33158       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
33159     } catch (std::out_of_range& e) {
33160       {
33161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33162       };
33163     } catch (std::exception& e) {
33164       {
33165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33166       };
33167     } catch (...) {
33168       {
33169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33170       };
33171     }
33172   }
33173 }
33174
33175
33176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
33177   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33178   Dali::ClippingBox arg2 ;
33179   Dali::ClippingBox *argp2 ;
33180
33181   arg1 = (Dali::Layer *)jarg1;
33182   argp2 = (Dali::ClippingBox *)jarg2;
33183   if (!argp2) {
33184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
33185     return ;
33186   }
33187   arg2 = *argp2;
33188   {
33189     try {
33190       (arg1)->SetClippingBox(arg2);
33191     } catch (std::out_of_range& e) {
33192       {
33193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33194       };
33195     } catch (std::exception& e) {
33196       {
33197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33198       };
33199     } catch (...) {
33200       {
33201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33202       };
33203     }
33204   }
33205 }
33206
33207
33208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
33209   void * jresult ;
33210   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33211   Dali::ClippingBox result;
33212
33213   arg1 = (Dali::Layer *)jarg1;
33214   {
33215     try {
33216       result = ((Dali::Layer const *)arg1)->GetClippingBox();
33217     } catch (std::out_of_range& e) {
33218       {
33219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33220       };
33221     } catch (std::exception& e) {
33222       {
33223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33224       };
33225     } catch (...) {
33226       {
33227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33228       };
33229     }
33230   }
33231   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
33232   return jresult;
33233 }
33234
33235
33236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
33237   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33238   bool arg2 ;
33239
33240   arg1 = (Dali::Layer *)jarg1;
33241   arg2 = jarg2 ? true : false;
33242   {
33243     try {
33244       (arg1)->SetDepthTestDisabled(arg2);
33245     } catch (std::out_of_range& e) {
33246       {
33247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33248       };
33249     } catch (std::exception& e) {
33250       {
33251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33252       };
33253     } catch (...) {
33254       {
33255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33256       };
33257     }
33258   }
33259 }
33260
33261
33262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
33263   unsigned int jresult ;
33264   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33265   bool result;
33266
33267   arg1 = (Dali::Layer *)jarg1;
33268   {
33269     try {
33270       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
33271     } catch (std::out_of_range& e) {
33272       {
33273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33274       };
33275     } catch (std::exception& e) {
33276       {
33277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33278       };
33279     } catch (...) {
33280       {
33281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33282       };
33283     }
33284   }
33285   jresult = result;
33286   return jresult;
33287 }
33288
33289
33290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
33291   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33292   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
33293
33294   arg1 = (Dali::Layer *)jarg1;
33295   arg2 = (Dali::Layer::SortFunctionType)jarg2;
33296   {
33297     try {
33298       (arg1)->SetSortFunction(arg2);
33299     } catch (std::out_of_range& e) {
33300       {
33301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33302       };
33303     } catch (std::exception& e) {
33304       {
33305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33306       };
33307     } catch (...) {
33308       {
33309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33310       };
33311     }
33312   }
33313 }
33314
33315
33316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
33317   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33318   bool arg2 ;
33319
33320   arg1 = (Dali::Layer *)jarg1;
33321   arg2 = jarg2 ? true : false;
33322   {
33323     try {
33324       (arg1)->SetTouchConsumed(arg2);
33325     } catch (std::out_of_range& e) {
33326       {
33327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33328       };
33329     } catch (std::exception& e) {
33330       {
33331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33332       };
33333     } catch (...) {
33334       {
33335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33336       };
33337     }
33338   }
33339 }
33340
33341
33342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
33343   unsigned int jresult ;
33344   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33345   bool result;
33346
33347   arg1 = (Dali::Layer *)jarg1;
33348   {
33349     try {
33350       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
33351     } catch (std::out_of_range& e) {
33352       {
33353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33354       };
33355     } catch (std::exception& e) {
33356       {
33357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33358       };
33359     } catch (...) {
33360       {
33361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33362       };
33363     }
33364   }
33365   jresult = result;
33366   return jresult;
33367 }
33368
33369
33370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
33371   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33372   bool arg2 ;
33373
33374   arg1 = (Dali::Layer *)jarg1;
33375   arg2 = jarg2 ? true : false;
33376   {
33377     try {
33378       (arg1)->SetHoverConsumed(arg2);
33379     } catch (std::out_of_range& e) {
33380       {
33381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33382       };
33383     } catch (std::exception& e) {
33384       {
33385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33386       };
33387     } catch (...) {
33388       {
33389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33390       };
33391     }
33392   }
33393 }
33394
33395
33396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
33397   unsigned int jresult ;
33398   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
33399   bool result;
33400
33401   arg1 = (Dali::Layer *)jarg1;
33402   {
33403     try {
33404       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
33405     } catch (std::out_of_range& e) {
33406       {
33407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33408       };
33409     } catch (std::exception& e) {
33410       {
33411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33412       };
33413     } catch (...) {
33414       {
33415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33416       };
33417     }
33418   }
33419   jresult = result;
33420   return jresult;
33421 }
33422
33423
33424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
33425   void * jresult ;
33426   Dali::Vector4 *result = 0 ;
33427
33428   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
33429   jresult = (void *)result;
33430   return jresult;
33431 }
33432
33433
33434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
33435   void * jresult ;
33436   Dali::Vector4 *result = 0 ;
33437
33438   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
33439   jresult = (void *)result;
33440   return jresult;
33441 }
33442
33443
33444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
33445   void * jresult ;
33446   Dali::Stage *result = 0 ;
33447
33448   {
33449     try {
33450       result = (Dali::Stage *)new Dali::Stage();
33451     } catch (std::out_of_range& e) {
33452       {
33453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33454       };
33455     } catch (std::exception& e) {
33456       {
33457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33458       };
33459     } catch (...) {
33460       {
33461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33462       };
33463     }
33464   }
33465   jresult = (void *)result;
33466   return jresult;
33467 }
33468
33469
33470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
33471   void * jresult ;
33472   Dali::Stage result;
33473
33474   {
33475     try {
33476       result = Dali::Stage::GetCurrent();
33477     } catch (std::out_of_range& e) {
33478       {
33479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33480       };
33481     } catch (std::exception& e) {
33482       {
33483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33484       };
33485     } catch (...) {
33486       {
33487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33488       };
33489     }
33490   }
33491   jresult = new Dali::Stage((const Dali::Stage &)result);
33492   return jresult;
33493 }
33494
33495
33496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
33497   unsigned int jresult ;
33498   bool result;
33499
33500   {
33501     try {
33502       result = (bool)Dali::Stage::IsInstalled();
33503     } catch (std::out_of_range& e) {
33504       {
33505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33506       };
33507     } catch (std::exception& e) {
33508       {
33509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33510       };
33511     } catch (...) {
33512       {
33513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33514       };
33515     }
33516   }
33517   jresult = result;
33518   return jresult;
33519 }
33520
33521
33522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
33523   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33524
33525   arg1 = (Dali::Stage *)jarg1;
33526   {
33527     try {
33528       delete arg1;
33529     } catch (std::out_of_range& e) {
33530       {
33531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33532       };
33533     } catch (std::exception& e) {
33534       {
33535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33536       };
33537     } catch (...) {
33538       {
33539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33540       };
33541     }
33542   }
33543 }
33544
33545
33546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
33547   void * jresult ;
33548   Dali::Stage *arg1 = 0 ;
33549   Dali::Stage *result = 0 ;
33550
33551   arg1 = (Dali::Stage *)jarg1;
33552   if (!arg1) {
33553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33554     return 0;
33555   }
33556   {
33557     try {
33558       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
33559     } catch (std::out_of_range& e) {
33560       {
33561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33562       };
33563     } catch (std::exception& e) {
33564       {
33565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33566       };
33567     } catch (...) {
33568       {
33569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33570       };
33571     }
33572   }
33573   jresult = (void *)result;
33574   return jresult;
33575 }
33576
33577
33578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
33579   void * jresult ;
33580   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33581   Dali::Stage *arg2 = 0 ;
33582   Dali::Stage *result = 0 ;
33583
33584   arg1 = (Dali::Stage *)jarg1;
33585   arg2 = (Dali::Stage *)jarg2;
33586   if (!arg2) {
33587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
33588     return 0;
33589   }
33590   {
33591     try {
33592       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
33593     } catch (std::out_of_range& e) {
33594       {
33595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33596       };
33597     } catch (std::exception& e) {
33598       {
33599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33600       };
33601     } catch (...) {
33602       {
33603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33604       };
33605     }
33606   }
33607   jresult = (void *)result;
33608   return jresult;
33609 }
33610
33611
33612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
33613   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33614   Dali::Actor *arg2 = 0 ;
33615
33616   arg1 = (Dali::Stage *)jarg1;
33617   arg2 = (Dali::Actor *)jarg2;
33618   if (!arg2) {
33619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33620     return ;
33621   }
33622   {
33623     try {
33624       (arg1)->Add(*arg2);
33625     } catch (std::out_of_range& e) {
33626       {
33627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33628       };
33629     } catch (std::exception& e) {
33630       {
33631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33632       };
33633     } catch (...) {
33634       {
33635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33636       };
33637     }
33638   }
33639 }
33640
33641
33642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
33643   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33644   Dali::Actor *arg2 = 0 ;
33645
33646   arg1 = (Dali::Stage *)jarg1;
33647   arg2 = (Dali::Actor *)jarg2;
33648   if (!arg2) {
33649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
33650     return ;
33651   }
33652   {
33653     try {
33654       (arg1)->Remove(*arg2);
33655     } catch (std::out_of_range& e) {
33656       {
33657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33658       };
33659     } catch (std::exception& e) {
33660       {
33661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33662       };
33663     } catch (...) {
33664       {
33665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33666       };
33667     }
33668   }
33669 }
33670
33671
33672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
33673   void * jresult ;
33674   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33675   Dali::Vector2 result;
33676
33677   arg1 = (Dali::Stage *)jarg1;
33678   {
33679     try {
33680       result = ((Dali::Stage const *)arg1)->GetSize();
33681     } catch (std::out_of_range& e) {
33682       {
33683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33684       };
33685     } catch (std::exception& e) {
33686       {
33687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33688       };
33689     } catch (...) {
33690       {
33691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33692       };
33693     }
33694   }
33695   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33696   return jresult;
33697 }
33698
33699
33700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
33701   void * jresult ;
33702   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33703   Dali::RenderTaskList result;
33704
33705   arg1 = (Dali::Stage *)jarg1;
33706   {
33707     try {
33708       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
33709     } catch (std::out_of_range& e) {
33710       {
33711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33712       };
33713     } catch (std::exception& e) {
33714       {
33715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33716       };
33717     } catch (...) {
33718       {
33719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33720       };
33721     }
33722   }
33723   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
33724   return jresult;
33725 }
33726
33727
33728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
33729   unsigned int jresult ;
33730   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33731   unsigned int result;
33732
33733   arg1 = (Dali::Stage *)jarg1;
33734   {
33735     try {
33736       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
33737     } catch (std::out_of_range& e) {
33738       {
33739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33740       };
33741     } catch (std::exception& e) {
33742       {
33743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33744       };
33745     } catch (...) {
33746       {
33747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33748       };
33749     }
33750   }
33751   jresult = result;
33752   return jresult;
33753 }
33754
33755
33756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
33757   void * jresult ;
33758   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33759   unsigned int arg2 ;
33760   Dali::Layer result;
33761
33762   arg1 = (Dali::Stage *)jarg1;
33763   arg2 = (unsigned int)jarg2;
33764   {
33765     try {
33766       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
33767     } catch (std::out_of_range& e) {
33768       {
33769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33770       };
33771     } catch (std::exception& e) {
33772       {
33773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33774       };
33775     } catch (...) {
33776       {
33777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33778       };
33779     }
33780   }
33781   jresult = new Dali::Layer((const Dali::Layer &)result);
33782   return jresult;
33783 }
33784
33785
33786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
33787   void * jresult ;
33788   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33789   Dali::Layer result;
33790
33791   arg1 = (Dali::Stage *)jarg1;
33792   {
33793     try {
33794       result = ((Dali::Stage const *)arg1)->GetRootLayer();
33795     } catch (std::out_of_range& e) {
33796       {
33797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33798       };
33799     } catch (std::exception& e) {
33800       {
33801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33802       };
33803     } catch (...) {
33804       {
33805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33806       };
33807     }
33808   }
33809   jresult = new Dali::Layer((const Dali::Layer &)result);
33810   return jresult;
33811 }
33812
33813
33814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
33815   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33816   Dali::Vector4 arg2 ;
33817   Dali::Vector4 *argp2 ;
33818
33819   arg1 = (Dali::Stage *)jarg1;
33820   argp2 = (Dali::Vector4 *)jarg2;
33821   if (!argp2) {
33822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
33823     return ;
33824   }
33825   arg2 = *argp2;
33826   {
33827     try {
33828       (arg1)->SetBackgroundColor(arg2);
33829     } catch (std::out_of_range& e) {
33830       {
33831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33832       };
33833     } catch (std::exception& e) {
33834       {
33835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33836       };
33837     } catch (...) {
33838       {
33839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33840       };
33841     }
33842   }
33843 }
33844
33845
33846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
33847   void * jresult ;
33848   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33849   Dali::Vector4 result;
33850
33851   arg1 = (Dali::Stage *)jarg1;
33852   {
33853     try {
33854       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
33855     } catch (std::out_of_range& e) {
33856       {
33857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33858       };
33859     } catch (std::exception& e) {
33860       {
33861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33862       };
33863     } catch (...) {
33864       {
33865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33866       };
33867     }
33868   }
33869   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
33870   return jresult;
33871 }
33872
33873
33874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
33875   void * jresult ;
33876   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33877   Dali::Vector2 result;
33878
33879   arg1 = (Dali::Stage *)jarg1;
33880   {
33881     try {
33882       result = ((Dali::Stage const *)arg1)->GetDpi();
33883     } catch (std::out_of_range& e) {
33884       {
33885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33886       };
33887     } catch (std::exception& e) {
33888       {
33889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33890       };
33891     } catch (...) {
33892       {
33893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33894       };
33895     }
33896   }
33897   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
33898   return jresult;
33899 }
33900
33901
33902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
33903   void * jresult ;
33904   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33905   Dali::ObjectRegistry result;
33906
33907   arg1 = (Dali::Stage *)jarg1;
33908   {
33909     try {
33910       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
33911     } catch (std::out_of_range& e) {
33912       {
33913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33914       };
33915     } catch (std::exception& e) {
33916       {
33917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33918       };
33919     } catch (...) {
33920       {
33921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33922       };
33923     }
33924   }
33925   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
33926   return jresult;
33927 }
33928
33929
33930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
33931   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33932   float arg2 ;
33933
33934   arg1 = (Dali::Stage *)jarg1;
33935   arg2 = (float)jarg2;
33936   {
33937     try {
33938       (arg1)->KeepRendering(arg2);
33939     } catch (std::out_of_range& e) {
33940       {
33941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33942       };
33943     } catch (std::exception& e) {
33944       {
33945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33946       };
33947     } catch (...) {
33948       {
33949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33950       };
33951     }
33952   }
33953 }
33954
33955
33956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
33957   void * jresult ;
33958   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33959   Dali::Stage::KeyEventSignalType *result = 0 ;
33960
33961   arg1 = (Dali::Stage *)jarg1;
33962   {
33963     try {
33964       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
33965     } catch (std::out_of_range& e) {
33966       {
33967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33968       };
33969     } catch (std::exception& e) {
33970       {
33971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33972       };
33973     } catch (...) {
33974       {
33975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33976       };
33977     }
33978   }
33979   jresult = (void *)result;
33980   return jresult;
33981 }
33982
33983
33984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
33985   void * jresult ;
33986   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
33987   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
33988
33989   arg1 = (Dali::Stage *)jarg1;
33990   {
33991     try {
33992       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
33993     } catch (std::out_of_range& e) {
33994       {
33995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33996       };
33997     } catch (std::exception& e) {
33998       {
33999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34000       };
34001     } catch (...) {
34002       {
34003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34004       };
34005     }
34006   }
34007   jresult = (void *)result;
34008   return jresult;
34009 }
34010
34011
34012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
34013   void * jresult ;
34014   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34015   Dali::Stage::TouchSignalType *result = 0 ;
34016
34017   arg1 = (Dali::Stage *)jarg1;
34018   {
34019     try {
34020       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
34021     } catch (std::out_of_range& e) {
34022       {
34023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34024       };
34025     } catch (std::exception& e) {
34026       {
34027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34028       };
34029     } catch (...) {
34030       {
34031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34032       };
34033     }
34034   }
34035   jresult = (void *)result;
34036   return jresult;
34037 }
34038
34039
34040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
34041   void * jresult ;
34042   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34043   Dali::Stage::WheelEventSignalType *result = 0 ;
34044
34045   arg1 = (Dali::Stage *)jarg1;
34046   {
34047     try {
34048       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
34049     } catch (std::out_of_range& e) {
34050       {
34051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34052       };
34053     } catch (std::exception& e) {
34054       {
34055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34056       };
34057     } catch (...) {
34058       {
34059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34060       };
34061     }
34062   }
34063   jresult = (void *)result;
34064   return jresult;
34065 }
34066
34067
34068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
34069   void * jresult ;
34070   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34071   Dali::Stage::ContextStatusSignal *result = 0 ;
34072
34073   arg1 = (Dali::Stage *)jarg1;
34074   {
34075     try {
34076       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
34077     } catch (std::out_of_range& e) {
34078       {
34079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34080       };
34081     } catch (std::exception& e) {
34082       {
34083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34084       };
34085     } catch (...) {
34086       {
34087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34088       };
34089     }
34090   }
34091   jresult = (void *)result;
34092   return jresult;
34093 }
34094
34095
34096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
34097   void * jresult ;
34098   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34099   Dali::Stage::ContextStatusSignal *result = 0 ;
34100
34101   arg1 = (Dali::Stage *)jarg1;
34102   {
34103     try {
34104       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
34105     } catch (std::out_of_range& e) {
34106       {
34107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34108       };
34109     } catch (std::exception& e) {
34110       {
34111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34112       };
34113     } catch (...) {
34114       {
34115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34116       };
34117     }
34118   }
34119   jresult = (void *)result;
34120   return jresult;
34121 }
34122
34123
34124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
34125   void * jresult ;
34126   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
34127   Dali::Stage::SceneCreatedSignalType *result = 0 ;
34128
34129   arg1 = (Dali::Stage *)jarg1;
34130   {
34131     try {
34132       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
34133     } catch (std::out_of_range& e) {
34134       {
34135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34136       };
34137     } catch (std::exception& e) {
34138       {
34139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34140       };
34141     } catch (...) {
34142       {
34143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34144       };
34145     }
34146   }
34147   jresult = (void *)result;
34148   return jresult;
34149 }
34150
34151
34152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
34153   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34154
34155   arg1 = (Dali::RelayoutContainer *)jarg1;
34156   {
34157     try {
34158       delete arg1;
34159     } catch (std::out_of_range& e) {
34160       {
34161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34162       };
34163     } catch (std::exception& e) {
34164       {
34165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34166       };
34167     } catch (...) {
34168       {
34169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34170       };
34171     }
34172   }
34173 }
34174
34175
34176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
34177   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
34178   Dali::Actor *arg2 = 0 ;
34179   Dali::Vector2 *arg3 = 0 ;
34180
34181   arg1 = (Dali::RelayoutContainer *)jarg1;
34182   arg2 = (Dali::Actor *)jarg2;
34183   if (!arg2) {
34184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34185     return ;
34186   }
34187   arg3 = (Dali::Vector2 *)jarg3;
34188   if (!arg3) {
34189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34190     return ;
34191   }
34192   {
34193     try {
34194       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
34195     } catch (std::out_of_range& e) {
34196       {
34197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34198       };
34199     } catch (std::exception& e) {
34200       {
34201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34202       };
34203     } catch (...) {
34204       {
34205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34206       };
34207     }
34208   }
34209 }
34210
34211
34212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
34213   void * jresult ;
34214   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34215   Dali::CustomActor result;
34216
34217   arg1 = (Dali::CustomActorImpl *)jarg1;
34218   {
34219     try {
34220       result = ((Dali::CustomActorImpl const *)arg1)->Self();
34221     } catch (std::out_of_range& e) {
34222       {
34223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34224       };
34225     } catch (std::exception& e) {
34226       {
34227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34228       };
34229     } catch (...) {
34230       {
34231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34232       };
34233     }
34234   }
34235   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
34236   return jresult;
34237 }
34238
34239
34240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
34241   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34242   int arg2 ;
34243
34244   arg1 = (Dali::CustomActorImpl *)jarg1;
34245   arg2 = (int)jarg2;
34246   {
34247     try {
34248       (arg1)->OnStageConnection(arg2);
34249     } catch (std::out_of_range& e) {
34250       {
34251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34252       };
34253     } catch (std::exception& e) {
34254       {
34255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34256       };
34257     } catch (...) {
34258       {
34259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34260       };
34261     }
34262   }
34263 }
34264
34265
34266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
34267   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34268
34269   arg1 = (Dali::CustomActorImpl *)jarg1;
34270   {
34271     try {
34272       (arg1)->OnStageDisconnection();
34273     } catch (std::out_of_range& e) {
34274       {
34275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34276       };
34277     } catch (std::exception& e) {
34278       {
34279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34280       };
34281     } catch (...) {
34282       {
34283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34284       };
34285     }
34286   }
34287 }
34288
34289
34290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
34291   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34292   Dali::Actor *arg2 = 0 ;
34293
34294   arg1 = (Dali::CustomActorImpl *)jarg1;
34295   arg2 = (Dali::Actor *)jarg2;
34296   if (!arg2) {
34297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34298     return ;
34299   }
34300   {
34301     try {
34302       (arg1)->OnChildAdd(*arg2);
34303     } catch (std::out_of_range& e) {
34304       {
34305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34306       };
34307     } catch (std::exception& e) {
34308       {
34309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34310       };
34311     } catch (...) {
34312       {
34313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34314       };
34315     }
34316   }
34317 }
34318
34319
34320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
34321   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34322   Dali::Actor *arg2 = 0 ;
34323
34324   arg1 = (Dali::CustomActorImpl *)jarg1;
34325   arg2 = (Dali::Actor *)jarg2;
34326   if (!arg2) {
34327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
34328     return ;
34329   }
34330   {
34331     try {
34332       (arg1)->OnChildRemove(*arg2);
34333     } catch (std::out_of_range& e) {
34334       {
34335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34336       };
34337     } catch (std::exception& e) {
34338       {
34339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34340       };
34341     } catch (...) {
34342       {
34343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34344       };
34345     }
34346   }
34347 }
34348
34349
34350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
34351   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34352   Dali::Property::Index arg2 ;
34353   Dali::Property::Value arg3 ;
34354   Dali::Property::Value *argp3 ;
34355
34356   arg1 = (Dali::CustomActorImpl *)jarg1;
34357   arg2 = (Dali::Property::Index)jarg2;
34358   argp3 = (Dali::Property::Value *)jarg3;
34359   if (!argp3) {
34360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
34361     return ;
34362   }
34363   arg3 = *argp3;
34364   {
34365     try {
34366       (arg1)->OnPropertySet(arg2,arg3);
34367     } catch (std::out_of_range& e) {
34368       {
34369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34370       };
34371     } catch (std::exception& e) {
34372       {
34373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34374       };
34375     } catch (...) {
34376       {
34377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34378       };
34379     }
34380   }
34381 }
34382
34383
34384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
34385   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34386   Dali::Vector3 *arg2 = 0 ;
34387
34388   arg1 = (Dali::CustomActorImpl *)jarg1;
34389   arg2 = (Dali::Vector3 *)jarg2;
34390   if (!arg2) {
34391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34392     return ;
34393   }
34394   {
34395     try {
34396       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
34397     } catch (std::out_of_range& e) {
34398       {
34399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34400       };
34401     } catch (std::exception& e) {
34402       {
34403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34404       };
34405     } catch (...) {
34406       {
34407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34408       };
34409     }
34410   }
34411 }
34412
34413
34414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
34415   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34416   Dali::Animation *arg2 = 0 ;
34417   Dali::Vector3 *arg3 = 0 ;
34418
34419   arg1 = (Dali::CustomActorImpl *)jarg1;
34420   arg2 = (Dali::Animation *)jarg2;
34421   if (!arg2) {
34422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
34423     return ;
34424   }
34425   arg3 = (Dali::Vector3 *)jarg3;
34426   if (!arg3) {
34427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34428     return ;
34429   }
34430   {
34431     try {
34432       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
34433     } catch (std::out_of_range& e) {
34434       {
34435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34436       };
34437     } catch (std::exception& e) {
34438       {
34439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34440       };
34441     } catch (...) {
34442       {
34443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34444       };
34445     }
34446   }
34447 }
34448
34449
34450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
34451   unsigned int jresult ;
34452   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34453   Dali::TouchEvent *arg2 = 0 ;
34454   bool result;
34455
34456   arg1 = (Dali::CustomActorImpl *)jarg1;
34457   arg2 = (Dali::TouchEvent *)jarg2;
34458   if (!arg2) {
34459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
34460     return 0;
34461   }
34462   {
34463     try {
34464       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
34465     } catch (std::out_of_range& e) {
34466       {
34467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34468       };
34469     } catch (std::exception& e) {
34470       {
34471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34472       };
34473     } catch (...) {
34474       {
34475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34476       };
34477     }
34478   }
34479   jresult = result;
34480   return jresult;
34481 }
34482
34483
34484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
34485   unsigned int jresult ;
34486   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34487   Dali::HoverEvent *arg2 = 0 ;
34488   bool result;
34489
34490   arg1 = (Dali::CustomActorImpl *)jarg1;
34491   arg2 = (Dali::HoverEvent *)jarg2;
34492   if (!arg2) {
34493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
34494     return 0;
34495   }
34496   {
34497     try {
34498       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
34499     } catch (std::out_of_range& e) {
34500       {
34501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34502       };
34503     } catch (std::exception& e) {
34504       {
34505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34506       };
34507     } catch (...) {
34508       {
34509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34510       };
34511     }
34512   }
34513   jresult = result;
34514   return jresult;
34515 }
34516
34517
34518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
34519   unsigned int jresult ;
34520   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34521   Dali::KeyEvent *arg2 = 0 ;
34522   bool result;
34523
34524   arg1 = (Dali::CustomActorImpl *)jarg1;
34525   arg2 = (Dali::KeyEvent *)jarg2;
34526   if (!arg2) {
34527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
34528     return 0;
34529   }
34530   {
34531     try {
34532       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
34533     } catch (std::out_of_range& e) {
34534       {
34535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34536       };
34537     } catch (std::exception& e) {
34538       {
34539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34540       };
34541     } catch (...) {
34542       {
34543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34544       };
34545     }
34546   }
34547   jresult = result;
34548   return jresult;
34549 }
34550
34551
34552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
34553   unsigned int jresult ;
34554   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34555   Dali::WheelEvent *arg2 = 0 ;
34556   bool result;
34557
34558   arg1 = (Dali::CustomActorImpl *)jarg1;
34559   arg2 = (Dali::WheelEvent *)jarg2;
34560   if (!arg2) {
34561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
34562     return 0;
34563   }
34564   {
34565     try {
34566       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
34567     } catch (std::out_of_range& e) {
34568       {
34569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34570       };
34571     } catch (std::exception& e) {
34572       {
34573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34574       };
34575     } catch (...) {
34576       {
34577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34578       };
34579     }
34580   }
34581   jresult = result;
34582   return jresult;
34583 }
34584
34585
34586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
34587   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34588   Dali::Vector2 *arg2 = 0 ;
34589   Dali::RelayoutContainer *arg3 = 0 ;
34590
34591   arg1 = (Dali::CustomActorImpl *)jarg1;
34592   arg2 = (Dali::Vector2 *)jarg2;
34593   if (!arg2) {
34594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34595     return ;
34596   }
34597   arg3 = (Dali::RelayoutContainer *)jarg3;
34598   if (!arg3) {
34599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
34600     return ;
34601   }
34602   {
34603     try {
34604       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
34605     } catch (std::out_of_range& e) {
34606       {
34607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34608       };
34609     } catch (std::exception& e) {
34610       {
34611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34612       };
34613     } catch (...) {
34614       {
34615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34616       };
34617     }
34618   }
34619 }
34620
34621
34622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
34623   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34624   Dali::ResizePolicy::Type arg2 ;
34625   Dali::Dimension::Type arg3 ;
34626
34627   arg1 = (Dali::CustomActorImpl *)jarg1;
34628   arg2 = (Dali::ResizePolicy::Type)jarg2;
34629   arg3 = (Dali::Dimension::Type)jarg3;
34630   {
34631     try {
34632       (arg1)->OnSetResizePolicy(arg2,arg3);
34633     } catch (std::out_of_range& e) {
34634       {
34635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34636       };
34637     } catch (std::exception& e) {
34638       {
34639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34640       };
34641     } catch (...) {
34642       {
34643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34644       };
34645     }
34646   }
34647 }
34648
34649
34650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
34651   void * jresult ;
34652   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34653   Dali::Vector3 result;
34654
34655   arg1 = (Dali::CustomActorImpl *)jarg1;
34656   {
34657     try {
34658       result = (arg1)->GetNaturalSize();
34659     } catch (std::out_of_range& e) {
34660       {
34661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34662       };
34663     } catch (std::exception& e) {
34664       {
34665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34666       };
34667     } catch (...) {
34668       {
34669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34670       };
34671     }
34672   }
34673   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34674   return jresult;
34675 }
34676
34677
34678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
34679   float jresult ;
34680   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34681   Dali::Actor *arg2 = 0 ;
34682   Dali::Dimension::Type arg3 ;
34683   float result;
34684
34685   arg1 = (Dali::CustomActorImpl *)jarg1;
34686   arg2 = (Dali::Actor *)jarg2;
34687   if (!arg2) {
34688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
34689     return 0;
34690   }
34691   arg3 = (Dali::Dimension::Type)jarg3;
34692   {
34693     try {
34694       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
34695     } catch (std::out_of_range& e) {
34696       {
34697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34698       };
34699     } catch (std::exception& e) {
34700       {
34701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34702       };
34703     } catch (...) {
34704       {
34705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34706       };
34707     }
34708   }
34709   jresult = result;
34710   return jresult;
34711 }
34712
34713
34714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
34715   float jresult ;
34716   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34717   float arg2 ;
34718   float result;
34719
34720   arg1 = (Dali::CustomActorImpl *)jarg1;
34721   arg2 = (float)jarg2;
34722   {
34723     try {
34724       result = (float)(arg1)->GetHeightForWidth(arg2);
34725     } catch (std::out_of_range& e) {
34726       {
34727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34728       };
34729     } catch (std::exception& e) {
34730       {
34731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34732       };
34733     } catch (...) {
34734       {
34735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34736       };
34737     }
34738   }
34739   jresult = result;
34740   return jresult;
34741 }
34742
34743
34744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
34745   float jresult ;
34746   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34747   float arg2 ;
34748   float result;
34749
34750   arg1 = (Dali::CustomActorImpl *)jarg1;
34751   arg2 = (float)jarg2;
34752   {
34753     try {
34754       result = (float)(arg1)->GetWidthForHeight(arg2);
34755     } catch (std::out_of_range& e) {
34756       {
34757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34758       };
34759     } catch (std::exception& e) {
34760       {
34761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34762       };
34763     } catch (...) {
34764       {
34765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34766       };
34767     }
34768   }
34769   jresult = result;
34770   return jresult;
34771 }
34772
34773
34774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
34775   unsigned int jresult ;
34776   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34777   Dali::Dimension::Type arg2 ;
34778   bool result;
34779
34780   arg1 = (Dali::CustomActorImpl *)jarg1;
34781   arg2 = (Dali::Dimension::Type)jarg2;
34782   {
34783     try {
34784       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
34785     } catch (std::out_of_range& e) {
34786       {
34787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34788       };
34789     } catch (std::exception& e) {
34790       {
34791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34792       };
34793     } catch (...) {
34794       {
34795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34796       };
34797     }
34798   }
34799   jresult = result;
34800   return jresult;
34801 }
34802
34803
34804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
34805   unsigned int jresult ;
34806   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34807   bool result;
34808
34809   arg1 = (Dali::CustomActorImpl *)jarg1;
34810   {
34811     try {
34812       result = (bool)(arg1)->RelayoutDependentOnChildren();
34813     } catch (std::out_of_range& e) {
34814       {
34815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34816       };
34817     } catch (std::exception& e) {
34818       {
34819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34820       };
34821     } catch (...) {
34822       {
34823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34824       };
34825     }
34826   }
34827   jresult = result;
34828   return jresult;
34829 }
34830
34831
34832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
34833   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34834   Dali::Dimension::Type arg2 ;
34835
34836   arg1 = (Dali::CustomActorImpl *)jarg1;
34837   arg2 = (Dali::Dimension::Type)jarg2;
34838   {
34839     try {
34840       (arg1)->OnCalculateRelayoutSize(arg2);
34841     } catch (std::out_of_range& e) {
34842       {
34843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34844       };
34845     } catch (std::exception& e) {
34846       {
34847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34848       };
34849     } catch (...) {
34850       {
34851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34852       };
34853     }
34854   }
34855 }
34856
34857
34858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
34859   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34860   float arg2 ;
34861   Dali::Dimension::Type arg3 ;
34862
34863   arg1 = (Dali::CustomActorImpl *)jarg1;
34864   arg2 = (float)jarg2;
34865   arg3 = (Dali::Dimension::Type)jarg3;
34866   {
34867     try {
34868       (arg1)->OnLayoutNegotiated(arg2,arg3);
34869     } catch (std::out_of_range& e) {
34870       {
34871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34872       };
34873     } catch (std::exception& e) {
34874       {
34875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34876       };
34877     } catch (...) {
34878       {
34879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34880       };
34881     }
34882   }
34883 }
34884
34885
34886 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
34887   unsigned int jresult ;
34888   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34889   bool result;
34890
34891   arg1 = (Dali::CustomActorImpl *)jarg1;
34892   {
34893     try {
34894       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
34895     } catch (std::out_of_range& e) {
34896       {
34897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34898       };
34899     } catch (std::exception& e) {
34900       {
34901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34902       };
34903     } catch (...) {
34904       {
34905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34906       };
34907     }
34908   }
34909   jresult = result;
34910   return jresult;
34911 }
34912
34913
34914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
34915   unsigned int jresult ;
34916   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34917   bool result;
34918
34919   arg1 = (Dali::CustomActorImpl *)jarg1;
34920   {
34921     try {
34922       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
34923     } catch (std::out_of_range& e) {
34924       {
34925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34926       };
34927     } catch (std::exception& e) {
34928       {
34929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34930       };
34931     } catch (...) {
34932       {
34933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34934       };
34935     }
34936   }
34937   jresult = result;
34938   return jresult;
34939 }
34940
34941
34942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
34943   unsigned int jresult ;
34944   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34945   bool result;
34946
34947   arg1 = (Dali::CustomActorImpl *)jarg1;
34948   {
34949     try {
34950       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
34951     } catch (std::out_of_range& e) {
34952       {
34953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34954       };
34955     } catch (std::exception& e) {
34956       {
34957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34958       };
34959     } catch (...) {
34960       {
34961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34962       };
34963     }
34964   }
34965   jresult = result;
34966   return jresult;
34967 }
34968
34969
34970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
34971   unsigned int jresult ;
34972   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
34973   bool result;
34974
34975   arg1 = (Dali::CustomActorImpl *)jarg1;
34976   {
34977     try {
34978       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
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 = result;
34994   return jresult;
34995 }
34996
34997
34998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
34999   void * jresult ;
35000   Dali::CustomActor *result = 0 ;
35001
35002   {
35003     try {
35004       result = (Dali::CustomActor *)new Dali::CustomActor();
35005     } catch (std::out_of_range& e) {
35006       {
35007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35008       };
35009     } catch (std::exception& e) {
35010       {
35011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35012       };
35013     } catch (...) {
35014       {
35015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35016       };
35017     }
35018   }
35019   jresult = (void *)result;
35020   return jresult;
35021 }
35022
35023
35024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
35025   void * jresult ;
35026   Dali::BaseHandle arg1 ;
35027   Dali::BaseHandle *argp1 ;
35028   Dali::CustomActor result;
35029
35030   argp1 = (Dali::BaseHandle *)jarg1;
35031   if (!argp1) {
35032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35033     return 0;
35034   }
35035   arg1 = *argp1;
35036   {
35037     try {
35038       result = Dali::CustomActor::DownCast(arg1);
35039     } catch (std::out_of_range& e) {
35040       {
35041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35042       };
35043     } catch (std::exception& e) {
35044       {
35045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35046       };
35047     } catch (...) {
35048       {
35049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35050       };
35051     }
35052   }
35053   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
35054   return jresult;
35055 }
35056
35057
35058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
35059   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35060
35061   arg1 = (Dali::CustomActor *)jarg1;
35062   {
35063     try {
35064       delete arg1;
35065     } catch (std::out_of_range& e) {
35066       {
35067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35068       };
35069     } catch (std::exception& e) {
35070       {
35071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35072       };
35073     } catch (...) {
35074       {
35075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35076       };
35077     }
35078   }
35079 }
35080
35081
35082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
35083   void * jresult ;
35084   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35085   Dali::CustomActorImpl *result = 0 ;
35086
35087   arg1 = (Dali::CustomActor *)jarg1;
35088   {
35089     try {
35090       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
35091     } catch (std::out_of_range& e) {
35092       {
35093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35094       };
35095     } catch (std::exception& e) {
35096       {
35097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35098       };
35099     } catch (...) {
35100       {
35101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35102       };
35103     }
35104   }
35105   jresult = (void *)result;
35106   return jresult;
35107 }
35108
35109
35110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
35111   void * jresult ;
35112   Dali::CustomActorImpl *arg1 = 0 ;
35113   Dali::CustomActor *result = 0 ;
35114
35115   arg1 = (Dali::CustomActorImpl *)jarg1;
35116   if (!arg1) {
35117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
35118     return 0;
35119   }
35120   {
35121     try {
35122       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
35123     } catch (std::out_of_range& e) {
35124       {
35125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35126       };
35127     } catch (std::exception& e) {
35128       {
35129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35130       };
35131     } catch (...) {
35132       {
35133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35134       };
35135     }
35136   }
35137   jresult = (void *)result;
35138   return jresult;
35139 }
35140
35141
35142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
35143   void * jresult ;
35144   Dali::CustomActor *arg1 = 0 ;
35145   Dali::CustomActor *result = 0 ;
35146
35147   arg1 = (Dali::CustomActor *)jarg1;
35148   if (!arg1) {
35149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35150     return 0;
35151   }
35152   {
35153     try {
35154       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
35155     } catch (std::out_of_range& e) {
35156       {
35157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35158       };
35159     } catch (std::exception& e) {
35160       {
35161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35162       };
35163     } catch (...) {
35164       {
35165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35166       };
35167     }
35168   }
35169   jresult = (void *)result;
35170   return jresult;
35171 }
35172
35173
35174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
35175   void * jresult ;
35176   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
35177   Dali::CustomActor *arg2 = 0 ;
35178   Dali::CustomActor *result = 0 ;
35179
35180   arg1 = (Dali::CustomActor *)jarg1;
35181   arg2 = (Dali::CustomActor *)jarg2;
35182   if (!arg2) {
35183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
35184     return 0;
35185   }
35186   {
35187     try {
35188       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
35189     } catch (std::out_of_range& e) {
35190       {
35191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35192       };
35193     } catch (std::exception& e) {
35194       {
35195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35196       };
35197     } catch (...) {
35198       {
35199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35200       };
35201     }
35202   }
35203   jresult = (void *)result;
35204   return jresult;
35205 }
35206
35207
35208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
35209   int jresult ;
35210   int result;
35211
35212   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
35213   jresult = (int)result;
35214   return jresult;
35215 }
35216
35217
35218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
35219   int jresult ;
35220   int result;
35221
35222   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
35223   jresult = (int)result;
35224   return jresult;
35225 }
35226
35227
35228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
35229   int jresult ;
35230   int result;
35231
35232   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
35233   jresult = (int)result;
35234   return jresult;
35235 }
35236
35237
35238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
35239   int jresult ;
35240   int result;
35241
35242   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
35243   jresult = (int)result;
35244   return jresult;
35245 }
35246
35247
35248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
35249   int jresult ;
35250   int result;
35251
35252   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
35253   jresult = (int)result;
35254   return jresult;
35255 }
35256
35257
35258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
35259   int jresult ;
35260   int result;
35261
35262   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
35263   jresult = (int)result;
35264   return jresult;
35265 }
35266
35267
35268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
35269   int jresult ;
35270   int result;
35271
35272   result = (int)Dali::PanGestureDetector::Property::PANNING;
35273   jresult = (int)result;
35274   return jresult;
35275 }
35276
35277
35278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
35279   void * jresult ;
35280   Dali::PanGestureDetector::Property *result = 0 ;
35281
35282   {
35283     try {
35284       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
35285     } catch (std::out_of_range& e) {
35286       {
35287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35288       };
35289     } catch (std::exception& e) {
35290       {
35291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35292       };
35293     } catch (...) {
35294       {
35295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35296       };
35297     }
35298   }
35299   jresult = (void *)result;
35300   return jresult;
35301 }
35302
35303
35304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
35305   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
35306
35307   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
35308   {
35309     try {
35310       delete arg1;
35311     } catch (std::out_of_range& e) {
35312       {
35313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35314       };
35315     } catch (std::exception& e) {
35316       {
35317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35318       };
35319     } catch (...) {
35320       {
35321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35322       };
35323     }
35324   }
35325 }
35326
35327
35328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
35329   void * jresult ;
35330   Dali::Radian *result = 0 ;
35331
35332   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
35333   jresult = (void *)result;
35334   return jresult;
35335 }
35336
35337
35338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
35339   void * jresult ;
35340   Dali::Radian *result = 0 ;
35341
35342   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
35343   jresult = (void *)result;
35344   return jresult;
35345 }
35346
35347
35348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
35349   void * jresult ;
35350   Dali::Radian *result = 0 ;
35351
35352   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
35353   jresult = (void *)result;
35354   return jresult;
35355 }
35356
35357
35358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
35359   void * jresult ;
35360   Dali::Radian *result = 0 ;
35361
35362   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
35363   jresult = (void *)result;
35364   return jresult;
35365 }
35366
35367
35368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
35369   void * jresult ;
35370   Dali::Radian *result = 0 ;
35371
35372   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
35373   jresult = (void *)result;
35374   return jresult;
35375 }
35376
35377
35378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
35379   void * jresult ;
35380   Dali::Radian *result = 0 ;
35381
35382   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
35383   jresult = (void *)result;
35384   return jresult;
35385 }
35386
35387
35388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
35389   void * jresult ;
35390   Dali::Radian *result = 0 ;
35391
35392   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
35393   jresult = (void *)result;
35394   return jresult;
35395 }
35396
35397
35398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
35399   void * jresult ;
35400   Dali::PanGestureDetector *result = 0 ;
35401
35402   {
35403     try {
35404       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
35405     } catch (std::out_of_range& e) {
35406       {
35407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35408       };
35409     } catch (std::exception& e) {
35410       {
35411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35412       };
35413     } catch (...) {
35414       {
35415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35416       };
35417     }
35418   }
35419   jresult = (void *)result;
35420   return jresult;
35421 }
35422
35423
35424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
35425   void * jresult ;
35426   Dali::PanGestureDetector result;
35427
35428   {
35429     try {
35430       result = Dali::PanGestureDetector::New();
35431     } catch (std::out_of_range& e) {
35432       {
35433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35434       };
35435     } catch (std::exception& e) {
35436       {
35437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35438       };
35439     } catch (...) {
35440       {
35441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35442       };
35443     }
35444   }
35445   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35446   return jresult;
35447 }
35448
35449
35450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
35451   void * jresult ;
35452   Dali::BaseHandle arg1 ;
35453   Dali::BaseHandle *argp1 ;
35454   Dali::PanGestureDetector result;
35455
35456   argp1 = (Dali::BaseHandle *)jarg1;
35457   if (!argp1) {
35458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
35459     return 0;
35460   }
35461   arg1 = *argp1;
35462   {
35463     try {
35464       result = Dali::PanGestureDetector::DownCast(arg1);
35465     } catch (std::out_of_range& e) {
35466       {
35467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35468       };
35469     } catch (std::exception& e) {
35470       {
35471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35472       };
35473     } catch (...) {
35474       {
35475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35476       };
35477     }
35478   }
35479   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
35480   return jresult;
35481 }
35482
35483
35484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
35485   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35486
35487   arg1 = (Dali::PanGestureDetector *)jarg1;
35488   {
35489     try {
35490       delete arg1;
35491     } catch (std::out_of_range& e) {
35492       {
35493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35494       };
35495     } catch (std::exception& e) {
35496       {
35497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35498       };
35499     } catch (...) {
35500       {
35501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35502       };
35503     }
35504   }
35505 }
35506
35507
35508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
35509   void * jresult ;
35510   Dali::PanGestureDetector *arg1 = 0 ;
35511   Dali::PanGestureDetector *result = 0 ;
35512
35513   arg1 = (Dali::PanGestureDetector *)jarg1;
35514   if (!arg1) {
35515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35516     return 0;
35517   }
35518   {
35519     try {
35520       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
35521     } catch (std::out_of_range& e) {
35522       {
35523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35524       };
35525     } catch (std::exception& e) {
35526       {
35527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35528       };
35529     } catch (...) {
35530       {
35531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35532       };
35533     }
35534   }
35535   jresult = (void *)result;
35536   return jresult;
35537 }
35538
35539
35540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
35541   void * jresult ;
35542   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35543   Dali::PanGestureDetector *arg2 = 0 ;
35544   Dali::PanGestureDetector *result = 0 ;
35545
35546   arg1 = (Dali::PanGestureDetector *)jarg1;
35547   arg2 = (Dali::PanGestureDetector *)jarg2;
35548   if (!arg2) {
35549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
35550     return 0;
35551   }
35552   {
35553     try {
35554       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
35555     } catch (std::out_of_range& e) {
35556       {
35557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35558       };
35559     } catch (std::exception& e) {
35560       {
35561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35562       };
35563     } catch (...) {
35564       {
35565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35566       };
35567     }
35568   }
35569   jresult = (void *)result;
35570   return jresult;
35571 }
35572
35573
35574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
35575   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35576   unsigned int arg2 ;
35577
35578   arg1 = (Dali::PanGestureDetector *)jarg1;
35579   arg2 = (unsigned int)jarg2;
35580   {
35581     try {
35582       (arg1)->SetMinimumTouchesRequired(arg2);
35583     } catch (std::out_of_range& e) {
35584       {
35585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35586       };
35587     } catch (std::exception& e) {
35588       {
35589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35590       };
35591     } catch (...) {
35592       {
35593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35594       };
35595     }
35596   }
35597 }
35598
35599
35600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
35601   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35602   unsigned int arg2 ;
35603
35604   arg1 = (Dali::PanGestureDetector *)jarg1;
35605   arg2 = (unsigned int)jarg2;
35606   {
35607     try {
35608       (arg1)->SetMaximumTouchesRequired(arg2);
35609     } catch (std::out_of_range& e) {
35610       {
35611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35612       };
35613     } catch (std::exception& e) {
35614       {
35615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35616       };
35617     } catch (...) {
35618       {
35619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35620       };
35621     }
35622   }
35623 }
35624
35625
35626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
35627   unsigned int jresult ;
35628   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35629   unsigned int result;
35630
35631   arg1 = (Dali::PanGestureDetector *)jarg1;
35632   {
35633     try {
35634       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
35635     } catch (std::out_of_range& e) {
35636       {
35637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35638       };
35639     } catch (std::exception& e) {
35640       {
35641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35642       };
35643     } catch (...) {
35644       {
35645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35646       };
35647     }
35648   }
35649   jresult = result;
35650   return jresult;
35651 }
35652
35653
35654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
35655   unsigned int jresult ;
35656   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35657   unsigned int result;
35658
35659   arg1 = (Dali::PanGestureDetector *)jarg1;
35660   {
35661     try {
35662       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
35663     } catch (std::out_of_range& e) {
35664       {
35665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35666       };
35667     } catch (std::exception& e) {
35668       {
35669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35670       };
35671     } catch (...) {
35672       {
35673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35674       };
35675     }
35676   }
35677   jresult = result;
35678   return jresult;
35679 }
35680
35681
35682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35683   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35684   Dali::Radian arg2 ;
35685   Dali::Radian arg3 ;
35686   Dali::Radian *argp2 ;
35687   Dali::Radian *argp3 ;
35688
35689   arg1 = (Dali::PanGestureDetector *)jarg1;
35690   argp2 = (Dali::Radian *)jarg2;
35691   if (!argp2) {
35692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35693     return ;
35694   }
35695   arg2 = *argp2;
35696   argp3 = (Dali::Radian *)jarg3;
35697   if (!argp3) {
35698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35699     return ;
35700   }
35701   arg3 = *argp3;
35702   {
35703     try {
35704       (arg1)->AddAngle(arg2,arg3);
35705     } catch (std::out_of_range& e) {
35706       {
35707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35708       };
35709     } catch (std::exception& e) {
35710       {
35711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35712       };
35713     } catch (...) {
35714       {
35715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35716       };
35717     }
35718   }
35719 }
35720
35721
35722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
35723   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35724   Dali::Radian arg2 ;
35725   Dali::Radian *argp2 ;
35726
35727   arg1 = (Dali::PanGestureDetector *)jarg1;
35728   argp2 = (Dali::Radian *)jarg2;
35729   if (!argp2) {
35730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35731     return ;
35732   }
35733   arg2 = *argp2;
35734   {
35735     try {
35736       (arg1)->AddAngle(arg2);
35737     } catch (std::out_of_range& e) {
35738       {
35739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35740       };
35741     } catch (std::exception& e) {
35742       {
35743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35744       };
35745     } catch (...) {
35746       {
35747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35748       };
35749     }
35750   }
35751 }
35752
35753
35754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35755   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35756   Dali::Radian arg2 ;
35757   Dali::Radian arg3 ;
35758   Dali::Radian *argp2 ;
35759   Dali::Radian *argp3 ;
35760
35761   arg1 = (Dali::PanGestureDetector *)jarg1;
35762   argp2 = (Dali::Radian *)jarg2;
35763   if (!argp2) {
35764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35765     return ;
35766   }
35767   arg2 = *argp2;
35768   argp3 = (Dali::Radian *)jarg3;
35769   if (!argp3) {
35770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35771     return ;
35772   }
35773   arg3 = *argp3;
35774   {
35775     try {
35776       (arg1)->AddDirection(arg2,arg3);
35777     } catch (std::out_of_range& e) {
35778       {
35779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35780       };
35781     } catch (std::exception& e) {
35782       {
35783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35784       };
35785     } catch (...) {
35786       {
35787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35788       };
35789     }
35790   }
35791 }
35792
35793
35794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
35795   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35796   Dali::Radian arg2 ;
35797   Dali::Radian *argp2 ;
35798
35799   arg1 = (Dali::PanGestureDetector *)jarg1;
35800   argp2 = (Dali::Radian *)jarg2;
35801   if (!argp2) {
35802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35803     return ;
35804   }
35805   arg2 = *argp2;
35806   {
35807     try {
35808       (arg1)->AddDirection(arg2);
35809     } catch (std::out_of_range& e) {
35810       {
35811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35812       };
35813     } catch (std::exception& e) {
35814       {
35815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35816       };
35817     } catch (...) {
35818       {
35819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35820       };
35821     }
35822   }
35823 }
35824
35825
35826 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
35827   unsigned long jresult ;
35828   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35829   size_t result;
35830
35831   arg1 = (Dali::PanGestureDetector *)jarg1;
35832   {
35833     try {
35834       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
35835     } catch (std::out_of_range& e) {
35836       {
35837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35838       };
35839     } catch (std::exception& e) {
35840       {
35841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35842       };
35843     } catch (...) {
35844       {
35845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35846       };
35847     }
35848   }
35849   jresult = (unsigned long)result;
35850   return jresult;
35851 }
35852
35853
35854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
35855   void * jresult ;
35856   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35857   size_t arg2 ;
35858   Dali::PanGestureDetector::AngleThresholdPair result;
35859
35860   arg1 = (Dali::PanGestureDetector *)jarg1;
35861   arg2 = (size_t)jarg2;
35862   {
35863     try {
35864       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
35865     } catch (std::out_of_range& e) {
35866       {
35867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35868       };
35869     } catch (std::exception& e) {
35870       {
35871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35872       };
35873     } catch (...) {
35874       {
35875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35876       };
35877     }
35878   }
35879   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
35880   return jresult;
35881 }
35882
35883
35884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
35885   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35886
35887   arg1 = (Dali::PanGestureDetector *)jarg1;
35888   {
35889     try {
35890       (arg1)->ClearAngles();
35891     } catch (std::out_of_range& e) {
35892       {
35893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35894       };
35895     } catch (std::exception& e) {
35896       {
35897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35898       };
35899     } catch (...) {
35900       {
35901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35902       };
35903     }
35904   }
35905 }
35906
35907
35908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
35909   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35910   Dali::Radian arg2 ;
35911   Dali::Radian *argp2 ;
35912
35913   arg1 = (Dali::PanGestureDetector *)jarg1;
35914   argp2 = (Dali::Radian *)jarg2;
35915   if (!argp2) {
35916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35917     return ;
35918   }
35919   arg2 = *argp2;
35920   {
35921     try {
35922       (arg1)->RemoveAngle(arg2);
35923     } catch (std::out_of_range& e) {
35924       {
35925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35926       };
35927     } catch (std::exception& e) {
35928       {
35929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35930       };
35931     } catch (...) {
35932       {
35933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35934       };
35935     }
35936   }
35937 }
35938
35939
35940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
35941   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35942   Dali::Radian arg2 ;
35943   Dali::Radian *argp2 ;
35944
35945   arg1 = (Dali::PanGestureDetector *)jarg1;
35946   argp2 = (Dali::Radian *)jarg2;
35947   if (!argp2) {
35948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
35949     return ;
35950   }
35951   arg2 = *argp2;
35952   {
35953     try {
35954       (arg1)->RemoveDirection(arg2);
35955     } catch (std::out_of_range& e) {
35956       {
35957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35958       };
35959     } catch (std::exception& e) {
35960       {
35961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35962       };
35963     } catch (...) {
35964       {
35965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35966       };
35967     }
35968   }
35969 }
35970
35971
35972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
35973   void * jresult ;
35974   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
35975   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
35976
35977   arg1 = (Dali::PanGestureDetector *)jarg1;
35978   {
35979     try {
35980       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
35981     } catch (std::out_of_range& e) {
35982       {
35983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35984       };
35985     } catch (std::exception& e) {
35986       {
35987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35988       };
35989     } catch (...) {
35990       {
35991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35992       };
35993     }
35994   }
35995   jresult = (void *)result;
35996   return jresult;
35997 }
35998
35999
36000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
36001   Dali::PanGesture *arg1 = 0 ;
36002
36003   arg1 = (Dali::PanGesture *)jarg1;
36004   if (!arg1) {
36005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36006     return ;
36007   }
36008   {
36009     try {
36010       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
36011     } catch (std::out_of_range& e) {
36012       {
36013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36014       };
36015     } catch (std::exception& e) {
36016       {
36017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36018       };
36019     } catch (...) {
36020       {
36021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36022       };
36023     }
36024   }
36025 }
36026
36027
36028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
36029   void * jresult ;
36030   Dali::PanGesture *result = 0 ;
36031
36032   {
36033     try {
36034       result = (Dali::PanGesture *)new Dali::PanGesture();
36035     } catch (std::out_of_range& e) {
36036       {
36037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36038       };
36039     } catch (std::exception& e) {
36040       {
36041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36042       };
36043     } catch (...) {
36044       {
36045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36046       };
36047     }
36048   }
36049   jresult = (void *)result;
36050   return jresult;
36051 }
36052
36053
36054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
36055   void * jresult ;
36056   Dali::Gesture::State arg1 ;
36057   Dali::PanGesture *result = 0 ;
36058
36059   arg1 = (Dali::Gesture::State)jarg1;
36060   {
36061     try {
36062       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
36063     } catch (std::out_of_range& e) {
36064       {
36065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36066       };
36067     } catch (std::exception& e) {
36068       {
36069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36070       };
36071     } catch (...) {
36072       {
36073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36074       };
36075     }
36076   }
36077   jresult = (void *)result;
36078   return jresult;
36079 }
36080
36081
36082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
36083   void * jresult ;
36084   Dali::PanGesture *arg1 = 0 ;
36085   Dali::PanGesture *result = 0 ;
36086
36087   arg1 = (Dali::PanGesture *)jarg1;
36088   if (!arg1) {
36089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36090     return 0;
36091   }
36092   {
36093     try {
36094       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
36095     } catch (std::out_of_range& e) {
36096       {
36097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36098       };
36099     } catch (std::exception& e) {
36100       {
36101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36102       };
36103     } catch (...) {
36104       {
36105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36106       };
36107     }
36108   }
36109   jresult = (void *)result;
36110   return jresult;
36111 }
36112
36113
36114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
36115   void * jresult ;
36116   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36117   Dali::PanGesture *arg2 = 0 ;
36118   Dali::PanGesture *result = 0 ;
36119
36120   arg1 = (Dali::PanGesture *)jarg1;
36121   arg2 = (Dali::PanGesture *)jarg2;
36122   if (!arg2) {
36123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
36124     return 0;
36125   }
36126   {
36127     try {
36128       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
36129     } catch (std::out_of_range& e) {
36130       {
36131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36132       };
36133     } catch (std::exception& e) {
36134       {
36135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36136       };
36137     } catch (...) {
36138       {
36139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36140       };
36141     }
36142   }
36143   jresult = (void *)result;
36144   return jresult;
36145 }
36146
36147
36148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
36149   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36150
36151   arg1 = (Dali::PanGesture *)jarg1;
36152   {
36153     try {
36154       delete arg1;
36155     } catch (std::out_of_range& e) {
36156       {
36157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36158       };
36159     } catch (std::exception& e) {
36160       {
36161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36162       };
36163     } catch (...) {
36164       {
36165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36166       };
36167     }
36168   }
36169 }
36170
36171
36172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
36173   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36174   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36175
36176   arg1 = (Dali::PanGesture *)jarg1;
36177   arg2 = (Dali::Vector2 *)jarg2;
36178   if (arg1) (arg1)->velocity = *arg2;
36179 }
36180
36181
36182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
36183   void * jresult ;
36184   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36185   Dali::Vector2 *result = 0 ;
36186
36187   arg1 = (Dali::PanGesture *)jarg1;
36188   result = (Dali::Vector2 *)& ((arg1)->velocity);
36189   jresult = (void *)result;
36190   return jresult;
36191 }
36192
36193
36194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
36195   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36196   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36197
36198   arg1 = (Dali::PanGesture *)jarg1;
36199   arg2 = (Dali::Vector2 *)jarg2;
36200   if (arg1) (arg1)->displacement = *arg2;
36201 }
36202
36203
36204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
36205   void * jresult ;
36206   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36207   Dali::Vector2 *result = 0 ;
36208
36209   arg1 = (Dali::PanGesture *)jarg1;
36210   result = (Dali::Vector2 *)& ((arg1)->displacement);
36211   jresult = (void *)result;
36212   return jresult;
36213 }
36214
36215
36216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
36217   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36218   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36219
36220   arg1 = (Dali::PanGesture *)jarg1;
36221   arg2 = (Dali::Vector2 *)jarg2;
36222   if (arg1) (arg1)->position = *arg2;
36223 }
36224
36225
36226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
36227   void * jresult ;
36228   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36229   Dali::Vector2 *result = 0 ;
36230
36231   arg1 = (Dali::PanGesture *)jarg1;
36232   result = (Dali::Vector2 *)& ((arg1)->position);
36233   jresult = (void *)result;
36234   return jresult;
36235 }
36236
36237
36238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
36239   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36240   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36241
36242   arg1 = (Dali::PanGesture *)jarg1;
36243   arg2 = (Dali::Vector2 *)jarg2;
36244   if (arg1) (arg1)->screenVelocity = *arg2;
36245 }
36246
36247
36248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
36249   void * jresult ;
36250   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36251   Dali::Vector2 *result = 0 ;
36252
36253   arg1 = (Dali::PanGesture *)jarg1;
36254   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
36255   jresult = (void *)result;
36256   return jresult;
36257 }
36258
36259
36260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
36261   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36262   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36263
36264   arg1 = (Dali::PanGesture *)jarg1;
36265   arg2 = (Dali::Vector2 *)jarg2;
36266   if (arg1) (arg1)->screenDisplacement = *arg2;
36267 }
36268
36269
36270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
36271   void * jresult ;
36272   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36273   Dali::Vector2 *result = 0 ;
36274
36275   arg1 = (Dali::PanGesture *)jarg1;
36276   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
36277   jresult = (void *)result;
36278   return jresult;
36279 }
36280
36281
36282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
36283   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36284   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36285
36286   arg1 = (Dali::PanGesture *)jarg1;
36287   arg2 = (Dali::Vector2 *)jarg2;
36288   if (arg1) (arg1)->screenPosition = *arg2;
36289 }
36290
36291
36292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
36293   void * jresult ;
36294   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36295   Dali::Vector2 *result = 0 ;
36296
36297   arg1 = (Dali::PanGesture *)jarg1;
36298   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
36299   jresult = (void *)result;
36300   return jresult;
36301 }
36302
36303
36304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
36305   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36306   unsigned int arg2 ;
36307
36308   arg1 = (Dali::PanGesture *)jarg1;
36309   arg2 = (unsigned int)jarg2;
36310   if (arg1) (arg1)->numberOfTouches = arg2;
36311 }
36312
36313
36314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
36315   unsigned int jresult ;
36316   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36317   unsigned int result;
36318
36319   arg1 = (Dali::PanGesture *)jarg1;
36320   result = (unsigned int) ((arg1)->numberOfTouches);
36321   jresult = result;
36322   return jresult;
36323 }
36324
36325
36326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
36327   float jresult ;
36328   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36329   float result;
36330
36331   arg1 = (Dali::PanGesture *)jarg1;
36332   {
36333     try {
36334       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
36335     } catch (std::out_of_range& e) {
36336       {
36337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36338       };
36339     } catch (std::exception& e) {
36340       {
36341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36342       };
36343     } catch (...) {
36344       {
36345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36346       };
36347     }
36348   }
36349   jresult = result;
36350   return jresult;
36351 }
36352
36353
36354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
36355   float jresult ;
36356   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36357   float result;
36358
36359   arg1 = (Dali::PanGesture *)jarg1;
36360   {
36361     try {
36362       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
36363     } catch (std::out_of_range& e) {
36364       {
36365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36366       };
36367     } catch (std::exception& e) {
36368       {
36369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36370       };
36371     } catch (...) {
36372       {
36373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36374       };
36375     }
36376   }
36377   jresult = result;
36378   return jresult;
36379 }
36380
36381
36382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
36383   float jresult ;
36384   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36385   float result;
36386
36387   arg1 = (Dali::PanGesture *)jarg1;
36388   {
36389     try {
36390       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
36391     } catch (std::out_of_range& e) {
36392       {
36393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36394       };
36395     } catch (std::exception& e) {
36396       {
36397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36398       };
36399     } catch (...) {
36400       {
36401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36402       };
36403     }
36404   }
36405   jresult = result;
36406   return jresult;
36407 }
36408
36409
36410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
36411   float jresult ;
36412   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
36413   float result;
36414
36415   arg1 = (Dali::PanGesture *)jarg1;
36416   {
36417     try {
36418       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
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 = result;
36434   return jresult;
36435 }
36436
36437
36438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
36439   void * jresult ;
36440   Dali::PinchGestureDetector *result = 0 ;
36441
36442   {
36443     try {
36444       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
36445     } catch (std::out_of_range& e) {
36446       {
36447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36448       };
36449     } catch (std::exception& e) {
36450       {
36451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36452       };
36453     } catch (...) {
36454       {
36455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36456       };
36457     }
36458   }
36459   jresult = (void *)result;
36460   return jresult;
36461 }
36462
36463
36464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
36465   void * jresult ;
36466   Dali::PinchGestureDetector result;
36467
36468   {
36469     try {
36470       result = Dali::PinchGestureDetector::New();
36471     } catch (std::out_of_range& e) {
36472       {
36473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36474       };
36475     } catch (std::exception& e) {
36476       {
36477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36478       };
36479     } catch (...) {
36480       {
36481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36482       };
36483     }
36484   }
36485   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36486   return jresult;
36487 }
36488
36489
36490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
36491   void * jresult ;
36492   Dali::BaseHandle arg1 ;
36493   Dali::BaseHandle *argp1 ;
36494   Dali::PinchGestureDetector result;
36495
36496   argp1 = (Dali::BaseHandle *)jarg1;
36497   if (!argp1) {
36498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36499     return 0;
36500   }
36501   arg1 = *argp1;
36502   {
36503     try {
36504       result = Dali::PinchGestureDetector::DownCast(arg1);
36505     } catch (std::out_of_range& e) {
36506       {
36507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36508       };
36509     } catch (std::exception& e) {
36510       {
36511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36512       };
36513     } catch (...) {
36514       {
36515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36516       };
36517     }
36518   }
36519   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
36520   return jresult;
36521 }
36522
36523
36524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
36525   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36526
36527   arg1 = (Dali::PinchGestureDetector *)jarg1;
36528   {
36529     try {
36530       delete arg1;
36531     } catch (std::out_of_range& e) {
36532       {
36533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36534       };
36535     } catch (std::exception& e) {
36536       {
36537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36538       };
36539     } catch (...) {
36540       {
36541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36542       };
36543     }
36544   }
36545 }
36546
36547
36548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
36549   void * jresult ;
36550   Dali::PinchGestureDetector *arg1 = 0 ;
36551   Dali::PinchGestureDetector *result = 0 ;
36552
36553   arg1 = (Dali::PinchGestureDetector *)jarg1;
36554   if (!arg1) {
36555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36556     return 0;
36557   }
36558   {
36559     try {
36560       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
36561     } catch (std::out_of_range& e) {
36562       {
36563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36564       };
36565     } catch (std::exception& e) {
36566       {
36567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36568       };
36569     } catch (...) {
36570       {
36571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36572       };
36573     }
36574   }
36575   jresult = (void *)result;
36576   return jresult;
36577 }
36578
36579
36580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
36581   void * jresult ;
36582   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36583   Dali::PinchGestureDetector *arg2 = 0 ;
36584   Dali::PinchGestureDetector *result = 0 ;
36585
36586   arg1 = (Dali::PinchGestureDetector *)jarg1;
36587   arg2 = (Dali::PinchGestureDetector *)jarg2;
36588   if (!arg2) {
36589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
36590     return 0;
36591   }
36592   {
36593     try {
36594       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
36595     } catch (std::out_of_range& e) {
36596       {
36597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36598       };
36599     } catch (std::exception& e) {
36600       {
36601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36602       };
36603     } catch (...) {
36604       {
36605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36606       };
36607     }
36608   }
36609   jresult = (void *)result;
36610   return jresult;
36611 }
36612
36613
36614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
36615   void * jresult ;
36616   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
36617   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
36618
36619   arg1 = (Dali::PinchGestureDetector *)jarg1;
36620   {
36621     try {
36622       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
36623     } catch (std::out_of_range& e) {
36624       {
36625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36626       };
36627     } catch (std::exception& e) {
36628       {
36629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36630       };
36631     } catch (...) {
36632       {
36633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36634       };
36635     }
36636   }
36637   jresult = (void *)result;
36638   return jresult;
36639 }
36640
36641
36642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
36643   void * jresult ;
36644   Dali::Gesture::State arg1 ;
36645   Dali::PinchGesture *result = 0 ;
36646
36647   arg1 = (Dali::Gesture::State)jarg1;
36648   {
36649     try {
36650       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
36651     } catch (std::out_of_range& e) {
36652       {
36653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36654       };
36655     } catch (std::exception& e) {
36656       {
36657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36658       };
36659     } catch (...) {
36660       {
36661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36662       };
36663     }
36664   }
36665   jresult = (void *)result;
36666   return jresult;
36667 }
36668
36669
36670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
36671   void * jresult ;
36672   Dali::PinchGesture *arg1 = 0 ;
36673   Dali::PinchGesture *result = 0 ;
36674
36675   arg1 = (Dali::PinchGesture *)jarg1;
36676   if (!arg1) {
36677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36678     return 0;
36679   }
36680   {
36681     try {
36682       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
36683     } catch (std::out_of_range& e) {
36684       {
36685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36686       };
36687     } catch (std::exception& e) {
36688       {
36689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36690       };
36691     } catch (...) {
36692       {
36693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36694       };
36695     }
36696   }
36697   jresult = (void *)result;
36698   return jresult;
36699 }
36700
36701
36702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
36703   void * jresult ;
36704   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36705   Dali::PinchGesture *arg2 = 0 ;
36706   Dali::PinchGesture *result = 0 ;
36707
36708   arg1 = (Dali::PinchGesture *)jarg1;
36709   arg2 = (Dali::PinchGesture *)jarg2;
36710   if (!arg2) {
36711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
36712     return 0;
36713   }
36714   {
36715     try {
36716       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
36717     } catch (std::out_of_range& e) {
36718       {
36719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36720       };
36721     } catch (std::exception& e) {
36722       {
36723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36724       };
36725     } catch (...) {
36726       {
36727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36728       };
36729     }
36730   }
36731   jresult = (void *)result;
36732   return jresult;
36733 }
36734
36735
36736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
36737   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36738
36739   arg1 = (Dali::PinchGesture *)jarg1;
36740   {
36741     try {
36742       delete arg1;
36743     } catch (std::out_of_range& e) {
36744       {
36745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36746       };
36747     } catch (std::exception& e) {
36748       {
36749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36750       };
36751     } catch (...) {
36752       {
36753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36754       };
36755     }
36756   }
36757 }
36758
36759
36760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
36761   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36762   float arg2 ;
36763
36764   arg1 = (Dali::PinchGesture *)jarg1;
36765   arg2 = (float)jarg2;
36766   if (arg1) (arg1)->scale = arg2;
36767 }
36768
36769
36770 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
36771   float jresult ;
36772   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36773   float result;
36774
36775   arg1 = (Dali::PinchGesture *)jarg1;
36776   result = (float) ((arg1)->scale);
36777   jresult = result;
36778   return jresult;
36779 }
36780
36781
36782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
36783   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36784   float arg2 ;
36785
36786   arg1 = (Dali::PinchGesture *)jarg1;
36787   arg2 = (float)jarg2;
36788   if (arg1) (arg1)->speed = arg2;
36789 }
36790
36791
36792 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
36793   float jresult ;
36794   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36795   float result;
36796
36797   arg1 = (Dali::PinchGesture *)jarg1;
36798   result = (float) ((arg1)->speed);
36799   jresult = result;
36800   return jresult;
36801 }
36802
36803
36804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
36805   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36806   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36807
36808   arg1 = (Dali::PinchGesture *)jarg1;
36809   arg2 = (Dali::Vector2 *)jarg2;
36810   if (arg1) (arg1)->screenCenterPoint = *arg2;
36811 }
36812
36813
36814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
36815   void * jresult ;
36816   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36817   Dali::Vector2 *result = 0 ;
36818
36819   arg1 = (Dali::PinchGesture *)jarg1;
36820   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
36821   jresult = (void *)result;
36822   return jresult;
36823 }
36824
36825
36826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
36827   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36828   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
36829
36830   arg1 = (Dali::PinchGesture *)jarg1;
36831   arg2 = (Dali::Vector2 *)jarg2;
36832   if (arg1) (arg1)->localCenterPoint = *arg2;
36833 }
36834
36835
36836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
36837   void * jresult ;
36838   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
36839   Dali::Vector2 *result = 0 ;
36840
36841   arg1 = (Dali::PinchGesture *)jarg1;
36842   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
36843   jresult = (void *)result;
36844   return jresult;
36845 }
36846
36847
36848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
36849   void * jresult ;
36850   Dali::TapGestureDetector *result = 0 ;
36851
36852   {
36853     try {
36854       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
36855     } catch (std::out_of_range& e) {
36856       {
36857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36858       };
36859     } catch (std::exception& e) {
36860       {
36861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36862       };
36863     } catch (...) {
36864       {
36865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36866       };
36867     }
36868   }
36869   jresult = (void *)result;
36870   return jresult;
36871 }
36872
36873
36874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
36875   void * jresult ;
36876   Dali::TapGestureDetector result;
36877
36878   {
36879     try {
36880       result = Dali::TapGestureDetector::New();
36881     } catch (std::out_of_range& e) {
36882       {
36883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36884       };
36885     } catch (std::exception& e) {
36886       {
36887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36888       };
36889     } catch (...) {
36890       {
36891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36892       };
36893     }
36894   }
36895   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36896   return jresult;
36897 }
36898
36899
36900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
36901   void * jresult ;
36902   unsigned int arg1 ;
36903   Dali::TapGestureDetector result;
36904
36905   arg1 = (unsigned int)jarg1;
36906   {
36907     try {
36908       result = Dali::TapGestureDetector::New(arg1);
36909     } catch (std::out_of_range& e) {
36910       {
36911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36912       };
36913     } catch (std::exception& e) {
36914       {
36915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36916       };
36917     } catch (...) {
36918       {
36919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36920       };
36921     }
36922   }
36923   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36924   return jresult;
36925 }
36926
36927
36928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
36929   void * jresult ;
36930   Dali::BaseHandle arg1 ;
36931   Dali::BaseHandle *argp1 ;
36932   Dali::TapGestureDetector result;
36933
36934   argp1 = (Dali::BaseHandle *)jarg1;
36935   if (!argp1) {
36936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
36937     return 0;
36938   }
36939   arg1 = *argp1;
36940   {
36941     try {
36942       result = Dali::TapGestureDetector::DownCast(arg1);
36943     } catch (std::out_of_range& e) {
36944       {
36945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36946       };
36947     } catch (std::exception& e) {
36948       {
36949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36950       };
36951     } catch (...) {
36952       {
36953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36954       };
36955     }
36956   }
36957   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
36958   return jresult;
36959 }
36960
36961
36962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
36963   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
36964
36965   arg1 = (Dali::TapGestureDetector *)jarg1;
36966   {
36967     try {
36968       delete arg1;
36969     } catch (std::out_of_range& e) {
36970       {
36971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36972       };
36973     } catch (std::exception& e) {
36974       {
36975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36976       };
36977     } catch (...) {
36978       {
36979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36980       };
36981     }
36982   }
36983 }
36984
36985
36986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
36987   void * jresult ;
36988   Dali::TapGestureDetector *arg1 = 0 ;
36989   Dali::TapGestureDetector *result = 0 ;
36990
36991   arg1 = (Dali::TapGestureDetector *)jarg1;
36992   if (!arg1) {
36993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
36994     return 0;
36995   }
36996   {
36997     try {
36998       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
36999     } catch (std::out_of_range& e) {
37000       {
37001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37002       };
37003     } catch (std::exception& e) {
37004       {
37005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37006       };
37007     } catch (...) {
37008       {
37009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37010       };
37011     }
37012   }
37013   jresult = (void *)result;
37014   return jresult;
37015 }
37016
37017
37018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
37019   void * jresult ;
37020   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37021   Dali::TapGestureDetector *arg2 = 0 ;
37022   Dali::TapGestureDetector *result = 0 ;
37023
37024   arg1 = (Dali::TapGestureDetector *)jarg1;
37025   arg2 = (Dali::TapGestureDetector *)jarg2;
37026   if (!arg2) {
37027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
37028     return 0;
37029   }
37030   {
37031     try {
37032       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
37033     } catch (std::out_of_range& e) {
37034       {
37035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37036       };
37037     } catch (std::exception& e) {
37038       {
37039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37040       };
37041     } catch (...) {
37042       {
37043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37044       };
37045     }
37046   }
37047   jresult = (void *)result;
37048   return jresult;
37049 }
37050
37051
37052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
37053   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37054   unsigned int arg2 ;
37055
37056   arg1 = (Dali::TapGestureDetector *)jarg1;
37057   arg2 = (unsigned int)jarg2;
37058   {
37059     try {
37060       (arg1)->SetMinimumTapsRequired(arg2);
37061     } catch (std::out_of_range& e) {
37062       {
37063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37064       };
37065     } catch (std::exception& e) {
37066       {
37067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37068       };
37069     } catch (...) {
37070       {
37071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37072       };
37073     }
37074   }
37075 }
37076
37077
37078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
37079   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37080   unsigned int arg2 ;
37081
37082   arg1 = (Dali::TapGestureDetector *)jarg1;
37083   arg2 = (unsigned int)jarg2;
37084   {
37085     try {
37086       (arg1)->SetMaximumTapsRequired(arg2);
37087     } catch (std::out_of_range& e) {
37088       {
37089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37090       };
37091     } catch (std::exception& e) {
37092       {
37093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37094       };
37095     } catch (...) {
37096       {
37097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37098       };
37099     }
37100   }
37101 }
37102
37103
37104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
37105   unsigned int jresult ;
37106   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37107   unsigned int result;
37108
37109   arg1 = (Dali::TapGestureDetector *)jarg1;
37110   {
37111     try {
37112       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
37113     } catch (std::out_of_range& e) {
37114       {
37115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37116       };
37117     } catch (std::exception& e) {
37118       {
37119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37120       };
37121     } catch (...) {
37122       {
37123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37124       };
37125     }
37126   }
37127   jresult = result;
37128   return jresult;
37129 }
37130
37131
37132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
37133   unsigned int jresult ;
37134   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37135   unsigned int result;
37136
37137   arg1 = (Dali::TapGestureDetector *)jarg1;
37138   {
37139     try {
37140       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
37141     } catch (std::out_of_range& e) {
37142       {
37143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37144       };
37145     } catch (std::exception& e) {
37146       {
37147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37148       };
37149     } catch (...) {
37150       {
37151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37152       };
37153     }
37154   }
37155   jresult = result;
37156   return jresult;
37157 }
37158
37159
37160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
37161   void * jresult ;
37162   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
37163   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
37164
37165   arg1 = (Dali::TapGestureDetector *)jarg1;
37166   {
37167     try {
37168       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
37169     } catch (std::out_of_range& e) {
37170       {
37171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37172       };
37173     } catch (std::exception& e) {
37174       {
37175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37176       };
37177     } catch (...) {
37178       {
37179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37180       };
37181     }
37182   }
37183   jresult = (void *)result;
37184   return jresult;
37185 }
37186
37187
37188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
37189   void * jresult ;
37190   Dali::TapGesture *result = 0 ;
37191
37192   {
37193     try {
37194       result = (Dali::TapGesture *)new Dali::TapGesture();
37195     } catch (std::out_of_range& e) {
37196       {
37197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37198       };
37199     } catch (std::exception& e) {
37200       {
37201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37202       };
37203     } catch (...) {
37204       {
37205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37206       };
37207     }
37208   }
37209   jresult = (void *)result;
37210   return jresult;
37211 }
37212
37213
37214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
37215   void * jresult ;
37216   Dali::TapGesture *arg1 = 0 ;
37217   Dali::TapGesture *result = 0 ;
37218
37219   arg1 = (Dali::TapGesture *)jarg1;
37220   if (!arg1) {
37221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37222     return 0;
37223   }
37224   {
37225     try {
37226       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
37227     } catch (std::out_of_range& e) {
37228       {
37229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37230       };
37231     } catch (std::exception& e) {
37232       {
37233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37234       };
37235     } catch (...) {
37236       {
37237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37238       };
37239     }
37240   }
37241   jresult = (void *)result;
37242   return jresult;
37243 }
37244
37245
37246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
37247   void * jresult ;
37248   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37249   Dali::TapGesture *arg2 = 0 ;
37250   Dali::TapGesture *result = 0 ;
37251
37252   arg1 = (Dali::TapGesture *)jarg1;
37253   arg2 = (Dali::TapGesture *)jarg2;
37254   if (!arg2) {
37255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
37256     return 0;
37257   }
37258   {
37259     try {
37260       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
37261     } catch (std::out_of_range& e) {
37262       {
37263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37264       };
37265     } catch (std::exception& e) {
37266       {
37267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37268       };
37269     } catch (...) {
37270       {
37271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37272       };
37273     }
37274   }
37275   jresult = (void *)result;
37276   return jresult;
37277 }
37278
37279
37280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
37281   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37282
37283   arg1 = (Dali::TapGesture *)jarg1;
37284   {
37285     try {
37286       delete arg1;
37287     } catch (std::out_of_range& e) {
37288       {
37289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37290       };
37291     } catch (std::exception& e) {
37292       {
37293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37294       };
37295     } catch (...) {
37296       {
37297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37298       };
37299     }
37300   }
37301 }
37302
37303
37304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
37305   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37306   unsigned int arg2 ;
37307
37308   arg1 = (Dali::TapGesture *)jarg1;
37309   arg2 = (unsigned int)jarg2;
37310   if (arg1) (arg1)->numberOfTaps = arg2;
37311 }
37312
37313
37314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
37315   unsigned int jresult ;
37316   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37317   unsigned int result;
37318
37319   arg1 = (Dali::TapGesture *)jarg1;
37320   result = (unsigned int) ((arg1)->numberOfTaps);
37321   jresult = result;
37322   return jresult;
37323 }
37324
37325
37326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
37327   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37328   unsigned int arg2 ;
37329
37330   arg1 = (Dali::TapGesture *)jarg1;
37331   arg2 = (unsigned int)jarg2;
37332   if (arg1) (arg1)->numberOfTouches = arg2;
37333 }
37334
37335
37336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
37337   unsigned int jresult ;
37338   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37339   unsigned int result;
37340
37341   arg1 = (Dali::TapGesture *)jarg1;
37342   result = (unsigned int) ((arg1)->numberOfTouches);
37343   jresult = result;
37344   return jresult;
37345 }
37346
37347
37348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
37349   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37350   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37351
37352   arg1 = (Dali::TapGesture *)jarg1;
37353   arg2 = (Dali::Vector2 *)jarg2;
37354   if (arg1) (arg1)->screenPoint = *arg2;
37355 }
37356
37357
37358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
37359   void * jresult ;
37360   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37361   Dali::Vector2 *result = 0 ;
37362
37363   arg1 = (Dali::TapGesture *)jarg1;
37364   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
37365   jresult = (void *)result;
37366   return jresult;
37367 }
37368
37369
37370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
37371   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37372   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
37373
37374   arg1 = (Dali::TapGesture *)jarg1;
37375   arg2 = (Dali::Vector2 *)jarg2;
37376   if (arg1) (arg1)->localPoint = *arg2;
37377 }
37378
37379
37380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
37381   void * jresult ;
37382   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
37383   Dali::Vector2 *result = 0 ;
37384
37385   arg1 = (Dali::TapGesture *)jarg1;
37386   result = (Dali::Vector2 *)& ((arg1)->localPoint);
37387   jresult = (void *)result;
37388   return jresult;
37389 }
37390
37391
37392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
37393   void * jresult ;
37394   Dali::AlphaFunction *result = 0 ;
37395
37396   {
37397     try {
37398       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
37399     } catch (std::out_of_range& e) {
37400       {
37401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37402       };
37403     } catch (std::exception& e) {
37404       {
37405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37406       };
37407     } catch (...) {
37408       {
37409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37410       };
37411     }
37412   }
37413   jresult = (void *)result;
37414   return jresult;
37415 }
37416
37417
37418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
37419   void * jresult ;
37420   Dali::AlphaFunction::BuiltinFunction arg1 ;
37421   Dali::AlphaFunction *result = 0 ;
37422
37423   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
37424   {
37425     try {
37426       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37427     } catch (std::out_of_range& e) {
37428       {
37429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37430       };
37431     } catch (std::exception& e) {
37432       {
37433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37434       };
37435     } catch (...) {
37436       {
37437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37438       };
37439     }
37440   }
37441   jresult = (void *)result;
37442   return jresult;
37443 }
37444
37445
37446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
37447   void * jresult ;
37448   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
37449   Dali::AlphaFunction *result = 0 ;
37450
37451   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
37452   {
37453     try {
37454       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
37455     } catch (std::out_of_range& e) {
37456       {
37457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37458       };
37459     } catch (std::exception& e) {
37460       {
37461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37462       };
37463     } catch (...) {
37464       {
37465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37466       };
37467     }
37468   }
37469   jresult = (void *)result;
37470   return jresult;
37471 }
37472
37473
37474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
37475   void * jresult ;
37476   Dali::Vector2 *arg1 = 0 ;
37477   Dali::Vector2 *arg2 = 0 ;
37478   Dali::AlphaFunction *result = 0 ;
37479
37480   arg1 = (Dali::Vector2 *)jarg1;
37481   if (!arg1) {
37482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37483     return 0;
37484   }
37485   arg2 = (Dali::Vector2 *)jarg2;
37486   if (!arg2) {
37487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
37488     return 0;
37489   }
37490   {
37491     try {
37492       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
37493     } catch (std::out_of_range& e) {
37494       {
37495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37496       };
37497     } catch (std::exception& e) {
37498       {
37499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37500       };
37501     } catch (...) {
37502       {
37503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37504       };
37505     }
37506   }
37507   jresult = (void *)result;
37508   return jresult;
37509 }
37510
37511
37512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
37513   void * jresult ;
37514   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37515   Dali::Vector4 result;
37516
37517   arg1 = (Dali::AlphaFunction *)jarg1;
37518   {
37519     try {
37520       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
37521     } catch (std::out_of_range& e) {
37522       {
37523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37524       };
37525     } catch (std::exception& e) {
37526       {
37527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37528       };
37529     } catch (...) {
37530       {
37531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37532       };
37533     }
37534   }
37535   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
37536   return jresult;
37537 }
37538
37539
37540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
37541   void * jresult ;
37542   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37543   Dali::AlphaFunctionPrototype result;
37544
37545   arg1 = (Dali::AlphaFunction *)jarg1;
37546   {
37547     try {
37548       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
37549     } catch (std::out_of_range& e) {
37550       {
37551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37552       };
37553     } catch (std::exception& e) {
37554       {
37555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37556       };
37557     } catch (...) {
37558       {
37559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37560       };
37561     }
37562   }
37563   jresult = (void *)result;
37564   return jresult;
37565 }
37566
37567
37568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
37569   int jresult ;
37570   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37571   Dali::AlphaFunction::BuiltinFunction result;
37572
37573   arg1 = (Dali::AlphaFunction *)jarg1;
37574   {
37575     try {
37576       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
37577     } catch (std::out_of_range& e) {
37578       {
37579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37580       };
37581     } catch (std::exception& e) {
37582       {
37583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37584       };
37585     } catch (...) {
37586       {
37587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37588       };
37589     }
37590   }
37591   jresult = (int)result;
37592   return jresult;
37593 }
37594
37595
37596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
37597   int jresult ;
37598   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37599   Dali::AlphaFunction::Mode result;
37600
37601   arg1 = (Dali::AlphaFunction *)jarg1;
37602   {
37603     try {
37604       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
37605     } catch (std::out_of_range& e) {
37606       {
37607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37608       };
37609     } catch (std::exception& e) {
37610       {
37611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37612       };
37613     } catch (...) {
37614       {
37615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37616       };
37617     }
37618   }
37619   jresult = (int)result;
37620   return jresult;
37621 }
37622
37623
37624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
37625   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
37626
37627   arg1 = (Dali::AlphaFunction *)jarg1;
37628   {
37629     try {
37630       delete arg1;
37631     } catch (std::out_of_range& e) {
37632       {
37633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37634       };
37635     } catch (std::exception& e) {
37636       {
37637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37638       };
37639     } catch (...) {
37640       {
37641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37642       };
37643     }
37644   }
37645 }
37646
37647
37648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
37649   void * jresult ;
37650   Dali::KeyFrames result;
37651
37652   {
37653     try {
37654       result = Dali::KeyFrames::New();
37655     } catch (std::out_of_range& e) {
37656       {
37657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37658       };
37659     } catch (std::exception& e) {
37660       {
37661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37662       };
37663     } catch (...) {
37664       {
37665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37666       };
37667     }
37668   }
37669   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37670   return jresult;
37671 }
37672
37673
37674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
37675   void * jresult ;
37676   Dali::BaseHandle arg1 ;
37677   Dali::BaseHandle *argp1 ;
37678   Dali::KeyFrames result;
37679
37680   argp1 = (Dali::BaseHandle *)jarg1;
37681   if (!argp1) {
37682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37683     return 0;
37684   }
37685   arg1 = *argp1;
37686   {
37687     try {
37688       result = Dali::KeyFrames::DownCast(arg1);
37689     } catch (std::out_of_range& e) {
37690       {
37691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37692       };
37693     } catch (std::exception& e) {
37694       {
37695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37696       };
37697     } catch (...) {
37698       {
37699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37700       };
37701     }
37702   }
37703   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
37704   return jresult;
37705 }
37706
37707
37708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
37709   void * jresult ;
37710   Dali::KeyFrames *result = 0 ;
37711
37712   {
37713     try {
37714       result = (Dali::KeyFrames *)new Dali::KeyFrames();
37715     } catch (std::out_of_range& e) {
37716       {
37717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37718       };
37719     } catch (std::exception& e) {
37720       {
37721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37722       };
37723     } catch (...) {
37724       {
37725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37726       };
37727     }
37728   }
37729   jresult = (void *)result;
37730   return jresult;
37731 }
37732
37733
37734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
37735   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37736
37737   arg1 = (Dali::KeyFrames *)jarg1;
37738   {
37739     try {
37740       delete arg1;
37741     } catch (std::out_of_range& e) {
37742       {
37743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37744       };
37745     } catch (std::exception& e) {
37746       {
37747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37748       };
37749     } catch (...) {
37750       {
37751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37752       };
37753     }
37754   }
37755 }
37756
37757
37758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
37759   void * jresult ;
37760   Dali::KeyFrames *arg1 = 0 ;
37761   Dali::KeyFrames *result = 0 ;
37762
37763   arg1 = (Dali::KeyFrames *)jarg1;
37764   if (!arg1) {
37765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37766     return 0;
37767   }
37768   {
37769     try {
37770       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
37771     } catch (std::out_of_range& e) {
37772       {
37773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37774       };
37775     } catch (std::exception& e) {
37776       {
37777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37778       };
37779     } catch (...) {
37780       {
37781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37782       };
37783     }
37784   }
37785   jresult = (void *)result;
37786   return jresult;
37787 }
37788
37789
37790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
37791   void * jresult ;
37792   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37793   Dali::KeyFrames *arg2 = 0 ;
37794   Dali::KeyFrames *result = 0 ;
37795
37796   arg1 = (Dali::KeyFrames *)jarg1;
37797   arg2 = (Dali::KeyFrames *)jarg2;
37798   if (!arg2) {
37799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
37800     return 0;
37801   }
37802   {
37803     try {
37804       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
37805     } catch (std::out_of_range& e) {
37806       {
37807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37808       };
37809     } catch (std::exception& e) {
37810       {
37811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37812       };
37813     } catch (...) {
37814       {
37815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37816       };
37817     }
37818   }
37819   jresult = (void *)result;
37820   return jresult;
37821 }
37822
37823
37824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
37825   int jresult ;
37826   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37827   Dali::Property::Type result;
37828
37829   arg1 = (Dali::KeyFrames *)jarg1;
37830   {
37831     try {
37832       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
37833     } catch (std::out_of_range& e) {
37834       {
37835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37836       };
37837     } catch (std::exception& e) {
37838       {
37839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37840       };
37841     } catch (...) {
37842       {
37843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37844       };
37845     }
37846   }
37847   jresult = (int)result;
37848   return jresult;
37849 }
37850
37851
37852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
37853   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37854   float arg2 ;
37855   Dali::Property::Value arg3 ;
37856   Dali::Property::Value *argp3 ;
37857
37858   arg1 = (Dali::KeyFrames *)jarg1;
37859   arg2 = (float)jarg2;
37860   argp3 = (Dali::Property::Value *)jarg3;
37861   if (!argp3) {
37862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37863     return ;
37864   }
37865   arg3 = *argp3;
37866   {
37867     try {
37868       (arg1)->Add(arg2,arg3);
37869     } catch (std::out_of_range& e) {
37870       {
37871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37872       };
37873     } catch (std::exception& e) {
37874       {
37875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37876       };
37877     } catch (...) {
37878       {
37879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37880       };
37881     }
37882   }
37883 }
37884
37885
37886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
37887   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
37888   float arg2 ;
37889   Dali::Property::Value arg3 ;
37890   Dali::AlphaFunction arg4 ;
37891   Dali::Property::Value *argp3 ;
37892   Dali::AlphaFunction *argp4 ;
37893
37894   arg1 = (Dali::KeyFrames *)jarg1;
37895   arg2 = (float)jarg2;
37896   argp3 = (Dali::Property::Value *)jarg3;
37897   if (!argp3) {
37898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
37899     return ;
37900   }
37901   arg3 = *argp3;
37902   argp4 = (Dali::AlphaFunction *)jarg4;
37903   if (!argp4) {
37904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
37905     return ;
37906   }
37907   arg4 = *argp4;
37908   {
37909     try {
37910       (arg1)->Add(arg2,arg3,arg4);
37911     } catch (std::out_of_range& e) {
37912       {
37913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37914       };
37915     } catch (std::exception& e) {
37916       {
37917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37918       };
37919     } catch (...) {
37920       {
37921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37922       };
37923     }
37924   }
37925 }
37926
37927
37928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
37929   int jresult ;
37930   int result;
37931
37932   result = (int)Dali::Path::Property::POINTS;
37933   jresult = (int)result;
37934   return jresult;
37935 }
37936
37937
37938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
37939   int jresult ;
37940   int result;
37941
37942   result = (int)Dali::Path::Property::CONTROL_POINTS;
37943   jresult = (int)result;
37944   return jresult;
37945 }
37946
37947
37948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
37949   void * jresult ;
37950   Dali::Path::Property *result = 0 ;
37951
37952   {
37953     try {
37954       result = (Dali::Path::Property *)new Dali::Path::Property();
37955     } catch (std::out_of_range& e) {
37956       {
37957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37958       };
37959     } catch (std::exception& e) {
37960       {
37961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37962       };
37963     } catch (...) {
37964       {
37965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37966       };
37967     }
37968   }
37969   jresult = (void *)result;
37970   return jresult;
37971 }
37972
37973
37974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
37975   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
37976
37977   arg1 = (Dali::Path::Property *)jarg1;
37978   {
37979     try {
37980       delete arg1;
37981     } catch (std::out_of_range& e) {
37982       {
37983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37984       };
37985     } catch (std::exception& e) {
37986       {
37987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37988       };
37989     } catch (...) {
37990       {
37991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37992       };
37993     }
37994   }
37995 }
37996
37997
37998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
37999   void * jresult ;
38000   Dali::Path result;
38001
38002   {
38003     try {
38004       result = Dali::Path::New();
38005     } catch (std::out_of_range& e) {
38006       {
38007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38008       };
38009     } catch (std::exception& e) {
38010       {
38011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38012       };
38013     } catch (...) {
38014       {
38015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38016       };
38017     }
38018   }
38019   jresult = new Dali::Path((const Dali::Path &)result);
38020   return jresult;
38021 }
38022
38023
38024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
38025   void * jresult ;
38026   Dali::BaseHandle arg1 ;
38027   Dali::BaseHandle *argp1 ;
38028   Dali::Path result;
38029
38030   argp1 = (Dali::BaseHandle *)jarg1;
38031   if (!argp1) {
38032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38033     return 0;
38034   }
38035   arg1 = *argp1;
38036   {
38037     try {
38038       result = Dali::Path::DownCast(arg1);
38039     } catch (std::out_of_range& e) {
38040       {
38041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38042       };
38043     } catch (std::exception& e) {
38044       {
38045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38046       };
38047     } catch (...) {
38048       {
38049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38050       };
38051     }
38052   }
38053   jresult = new Dali::Path((const Dali::Path &)result);
38054   return jresult;
38055 }
38056
38057
38058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
38059   void * jresult ;
38060   Dali::Path *result = 0 ;
38061
38062   {
38063     try {
38064       result = (Dali::Path *)new Dali::Path();
38065     } catch (std::out_of_range& e) {
38066       {
38067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38068       };
38069     } catch (std::exception& e) {
38070       {
38071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38072       };
38073     } catch (...) {
38074       {
38075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38076       };
38077     }
38078   }
38079   jresult = (void *)result;
38080   return jresult;
38081 }
38082
38083
38084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
38085   Dali::Path *arg1 = (Dali::Path *) 0 ;
38086
38087   arg1 = (Dali::Path *)jarg1;
38088   {
38089     try {
38090       delete arg1;
38091     } catch (std::out_of_range& e) {
38092       {
38093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38094       };
38095     } catch (std::exception& e) {
38096       {
38097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38098       };
38099     } catch (...) {
38100       {
38101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38102       };
38103     }
38104   }
38105 }
38106
38107
38108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
38109   void * jresult ;
38110   Dali::Path *arg1 = 0 ;
38111   Dali::Path *result = 0 ;
38112
38113   arg1 = (Dali::Path *)jarg1;
38114   if (!arg1) {
38115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38116     return 0;
38117   }
38118   {
38119     try {
38120       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
38121     } catch (std::out_of_range& e) {
38122       {
38123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38124       };
38125     } catch (std::exception& e) {
38126       {
38127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38128       };
38129     } catch (...) {
38130       {
38131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38132       };
38133     }
38134   }
38135   jresult = (void *)result;
38136   return jresult;
38137 }
38138
38139
38140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
38141   void * jresult ;
38142   Dali::Path *arg1 = (Dali::Path *) 0 ;
38143   Dali::Path *arg2 = 0 ;
38144   Dali::Path *result = 0 ;
38145
38146   arg1 = (Dali::Path *)jarg1;
38147   arg2 = (Dali::Path *)jarg2;
38148   if (!arg2) {
38149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
38150     return 0;
38151   }
38152   {
38153     try {
38154       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
38155     } catch (std::out_of_range& e) {
38156       {
38157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38158       };
38159     } catch (std::exception& e) {
38160       {
38161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38162       };
38163     } catch (...) {
38164       {
38165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38166       };
38167     }
38168   }
38169   jresult = (void *)result;
38170   return jresult;
38171 }
38172
38173
38174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
38175   Dali::Path *arg1 = (Dali::Path *) 0 ;
38176   Dali::Vector3 *arg2 = 0 ;
38177
38178   arg1 = (Dali::Path *)jarg1;
38179   arg2 = (Dali::Vector3 *)jarg2;
38180   if (!arg2) {
38181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38182     return ;
38183   }
38184   {
38185     try {
38186       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
38187     } catch (std::out_of_range& e) {
38188       {
38189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38190       };
38191     } catch (std::exception& e) {
38192       {
38193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38194       };
38195     } catch (...) {
38196       {
38197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38198       };
38199     }
38200   }
38201 }
38202
38203
38204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
38205   Dali::Path *arg1 = (Dali::Path *) 0 ;
38206   Dali::Vector3 *arg2 = 0 ;
38207
38208   arg1 = (Dali::Path *)jarg1;
38209   arg2 = (Dali::Vector3 *)jarg2;
38210   if (!arg2) {
38211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38212     return ;
38213   }
38214   {
38215     try {
38216       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
38217     } catch (std::out_of_range& e) {
38218       {
38219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38220       };
38221     } catch (std::exception& e) {
38222       {
38223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38224       };
38225     } catch (...) {
38226       {
38227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38228       };
38229     }
38230   }
38231 }
38232
38233
38234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
38235   Dali::Path *arg1 = (Dali::Path *) 0 ;
38236   float arg2 ;
38237
38238   arg1 = (Dali::Path *)jarg1;
38239   arg2 = (float)jarg2;
38240   {
38241     try {
38242       (arg1)->GenerateControlPoints(arg2);
38243     } catch (std::out_of_range& e) {
38244       {
38245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38246       };
38247     } catch (std::exception& e) {
38248       {
38249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38250       };
38251     } catch (...) {
38252       {
38253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38254       };
38255     }
38256   }
38257 }
38258
38259
38260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
38261   Dali::Path *arg1 = (Dali::Path *) 0 ;
38262   float arg2 ;
38263   Dali::Vector3 *arg3 = 0 ;
38264   Dali::Vector3 *arg4 = 0 ;
38265
38266   arg1 = (Dali::Path *)jarg1;
38267   arg2 = (float)jarg2;
38268   arg3 = (Dali::Vector3 *)jarg3;
38269   if (!arg3) {
38270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38271     return ;
38272   }
38273   arg4 = (Dali::Vector3 *)jarg4;
38274   if (!arg4) {
38275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
38276     return ;
38277   }
38278   {
38279     try {
38280       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
38281     } catch (std::out_of_range& e) {
38282       {
38283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38284       };
38285     } catch (std::exception& e) {
38286       {
38287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38288       };
38289     } catch (...) {
38290       {
38291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38292       };
38293     }
38294   }
38295 }
38296
38297
38298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
38299   void * jresult ;
38300   Dali::Path *arg1 = (Dali::Path *) 0 ;
38301   size_t arg2 ;
38302   Dali::Vector3 *result = 0 ;
38303
38304   arg1 = (Dali::Path *)jarg1;
38305   arg2 = (size_t)jarg2;
38306   {
38307     try {
38308       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
38309     } catch (std::out_of_range& e) {
38310       {
38311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38312       };
38313     } catch (std::exception& e) {
38314       {
38315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38316       };
38317     } catch (...) {
38318       {
38319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38320       };
38321     }
38322   }
38323   jresult = (void *)result;
38324   return jresult;
38325 }
38326
38327
38328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
38329   void * jresult ;
38330   Dali::Path *arg1 = (Dali::Path *) 0 ;
38331   size_t arg2 ;
38332   Dali::Vector3 *result = 0 ;
38333
38334   arg1 = (Dali::Path *)jarg1;
38335   arg2 = (size_t)jarg2;
38336   {
38337     try {
38338       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
38339     } catch (std::out_of_range& e) {
38340       {
38341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38342       };
38343     } catch (std::exception& e) {
38344       {
38345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38346       };
38347     } catch (...) {
38348       {
38349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38350       };
38351     }
38352   }
38353   jresult = (void *)result;
38354   return jresult;
38355 }
38356
38357
38358 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
38359   unsigned long jresult ;
38360   Dali::Path *arg1 = (Dali::Path *) 0 ;
38361   size_t result;
38362
38363   arg1 = (Dali::Path *)jarg1;
38364   {
38365     try {
38366       result = ((Dali::Path const *)arg1)->GetPointCount();
38367     } catch (std::out_of_range& e) {
38368       {
38369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38370       };
38371     } catch (std::exception& e) {
38372       {
38373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38374       };
38375     } catch (...) {
38376       {
38377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38378       };
38379     }
38380   }
38381   jresult = (unsigned long)result;
38382   return jresult;
38383 }
38384
38385
38386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
38387   void * jresult ;
38388   float arg1 ;
38389   Dali::TimePeriod *result = 0 ;
38390
38391   arg1 = (float)jarg1;
38392   {
38393     try {
38394       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
38395     } catch (std::out_of_range& e) {
38396       {
38397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38398       };
38399     } catch (std::exception& e) {
38400       {
38401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38402       };
38403     } catch (...) {
38404       {
38405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38406       };
38407     }
38408   }
38409   jresult = (void *)result;
38410   return jresult;
38411 }
38412
38413
38414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
38415   void * jresult ;
38416   float arg1 ;
38417   float arg2 ;
38418   Dali::TimePeriod *result = 0 ;
38419
38420   arg1 = (float)jarg1;
38421   arg2 = (float)jarg2;
38422   {
38423     try {
38424       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
38425     } catch (std::out_of_range& e) {
38426       {
38427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38428       };
38429     } catch (std::exception& e) {
38430       {
38431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38432       };
38433     } catch (...) {
38434       {
38435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38436       };
38437     }
38438   }
38439   jresult = (void *)result;
38440   return jresult;
38441 }
38442
38443
38444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
38445   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38446
38447   arg1 = (Dali::TimePeriod *)jarg1;
38448   {
38449     try {
38450       delete arg1;
38451     } catch (std::out_of_range& e) {
38452       {
38453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38454       };
38455     } catch (std::exception& e) {
38456       {
38457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38458       };
38459     } catch (...) {
38460       {
38461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38462       };
38463     }
38464   }
38465 }
38466
38467
38468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
38469   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38470   float arg2 ;
38471
38472   arg1 = (Dali::TimePeriod *)jarg1;
38473   arg2 = (float)jarg2;
38474   if (arg1) (arg1)->delaySeconds = arg2;
38475 }
38476
38477
38478 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
38479   float jresult ;
38480   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38481   float result;
38482
38483   arg1 = (Dali::TimePeriod *)jarg1;
38484   result = (float) ((arg1)->delaySeconds);
38485   jresult = result;
38486   return jresult;
38487 }
38488
38489
38490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
38491   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38492   float arg2 ;
38493
38494   arg1 = (Dali::TimePeriod *)jarg1;
38495   arg2 = (float)jarg2;
38496   if (arg1) (arg1)->durationSeconds = arg2;
38497 }
38498
38499
38500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
38501   float jresult ;
38502   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
38503   float result;
38504
38505   arg1 = (Dali::TimePeriod *)jarg1;
38506   result = (float) ((arg1)->durationSeconds);
38507   jresult = result;
38508   return jresult;
38509 }
38510
38511
38512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_0() {
38513   void * jresult ;
38514   Dali::Animation *result = 0 ;
38515
38516   {
38517     try {
38518       result = (Dali::Animation *)new Dali::Animation();
38519     } catch (std::out_of_range& e) {
38520       {
38521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38522       };
38523     } catch (std::exception& e) {
38524       {
38525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38526       };
38527     } catch (...) {
38528       {
38529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38530       };
38531     }
38532   }
38533   jresult = (void *)result;
38534   return jresult;
38535 }
38536
38537
38538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_New(float jarg1) {
38539   void * jresult ;
38540   float arg1 ;
38541   Dali::Animation result;
38542
38543   arg1 = (float)jarg1;
38544   {
38545     try {
38546       result = Dali::Animation::New(arg1);
38547     } catch (std::out_of_range& e) {
38548       {
38549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38550       };
38551     } catch (std::exception& e) {
38552       {
38553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38554       };
38555     } catch (...) {
38556       {
38557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38558       };
38559     }
38560   }
38561   jresult = new Dali::Animation((const Dali::Animation &)result);
38562   return jresult;
38563 }
38564
38565
38566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_DownCast(void * jarg1) {
38567   void * jresult ;
38568   Dali::BaseHandle arg1 ;
38569   Dali::BaseHandle *argp1 ;
38570   Dali::Animation result;
38571
38572   argp1 = (Dali::BaseHandle *)jarg1;
38573   if (!argp1) {
38574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
38575     return 0;
38576   }
38577   arg1 = *argp1;
38578   {
38579     try {
38580       result = Dali::Animation::DownCast(arg1);
38581     } catch (std::out_of_range& e) {
38582       {
38583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38584       };
38585     } catch (std::exception& e) {
38586       {
38587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38588       };
38589     } catch (...) {
38590       {
38591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38592       };
38593     }
38594   }
38595   jresult = new Dali::Animation((const Dali::Animation &)result);
38596   return jresult;
38597 }
38598
38599
38600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Animation(void * jarg1) {
38601   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38602
38603   arg1 = (Dali::Animation *)jarg1;
38604   {
38605     try {
38606       delete arg1;
38607     } catch (std::out_of_range& e) {
38608       {
38609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38610       };
38611     } catch (std::exception& e) {
38612       {
38613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38614       };
38615     } catch (...) {
38616       {
38617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38618       };
38619     }
38620   }
38621 }
38622
38623
38624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Animation__SWIG_1(void * jarg1) {
38625   void * jresult ;
38626   Dali::Animation *arg1 = 0 ;
38627   Dali::Animation *result = 0 ;
38628
38629   arg1 = (Dali::Animation *)jarg1;
38630   if (!arg1) {
38631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38632     return 0;
38633   }
38634   {
38635     try {
38636       result = (Dali::Animation *)new Dali::Animation((Dali::Animation const &)*arg1);
38637     } catch (std::out_of_range& e) {
38638       {
38639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38640       };
38641     } catch (std::exception& e) {
38642       {
38643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38644       };
38645     } catch (...) {
38646       {
38647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38648       };
38649     }
38650   }
38651   jresult = (void *)result;
38652   return jresult;
38653 }
38654
38655
38656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_Assign(void * jarg1, void * jarg2) {
38657   void * jresult ;
38658   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38659   Dali::Animation *arg2 = 0 ;
38660   Dali::Animation *result = 0 ;
38661
38662   arg1 = (Dali::Animation *)jarg1;
38663   arg2 = (Dali::Animation *)jarg2;
38664   if (!arg2) {
38665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation const & type is null", 0);
38666     return 0;
38667   }
38668   {
38669     try {
38670       result = (Dali::Animation *) &(arg1)->operator =((Dali::Animation const &)*arg2);
38671     } catch (std::out_of_range& e) {
38672       {
38673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38674       };
38675     } catch (std::exception& e) {
38676       {
38677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38678       };
38679     } catch (...) {
38680       {
38681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38682       };
38683     }
38684   }
38685   jresult = (void *)result;
38686   return jresult;
38687 }
38688
38689
38690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDuration(void * jarg1, float jarg2) {
38691   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38692   float arg2 ;
38693
38694   arg1 = (Dali::Animation *)jarg1;
38695   arg2 = (float)jarg2;
38696   {
38697     try {
38698       (arg1)->SetDuration(arg2);
38699     } catch (std::out_of_range& e) {
38700       {
38701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38702       };
38703     } catch (std::exception& e) {
38704       {
38705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38706       };
38707     } catch (...) {
38708       {
38709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38710       };
38711     }
38712   }
38713 }
38714
38715
38716 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetDuration(void * jarg1) {
38717   float jresult ;
38718   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38719   float result;
38720
38721   arg1 = (Dali::Animation *)jarg1;
38722   {
38723     try {
38724       result = (float)((Dali::Animation const *)arg1)->GetDuration();
38725     } catch (std::out_of_range& e) {
38726       {
38727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38728       };
38729     } catch (std::exception& e) {
38730       {
38731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38732       };
38733     } catch (...) {
38734       {
38735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38736       };
38737     }
38738   }
38739   jresult = result;
38740   return jresult;
38741 }
38742
38743
38744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLooping(void * jarg1, unsigned int jarg2) {
38745   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38746   bool arg2 ;
38747
38748   arg1 = (Dali::Animation *)jarg1;
38749   arg2 = jarg2 ? true : false;
38750   {
38751     try {
38752       (arg1)->SetLooping(arg2);
38753     } catch (std::out_of_range& e) {
38754       {
38755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38756       };
38757     } catch (std::exception& e) {
38758       {
38759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38760       };
38761     } catch (...) {
38762       {
38763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38764       };
38765     }
38766   }
38767 }
38768
38769
38770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetLoopCount(void * jarg1, int jarg2) {
38771   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38772   int arg2 ;
38773
38774   arg1 = (Dali::Animation *)jarg1;
38775   arg2 = (int)jarg2;
38776   {
38777     try {
38778       (arg1)->SetLoopCount(arg2);
38779     } catch (std::out_of_range& e) {
38780       {
38781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38782       };
38783     } catch (std::exception& e) {
38784       {
38785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38786       };
38787     } catch (...) {
38788       {
38789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38790       };
38791     }
38792   }
38793 }
38794
38795
38796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetLoopCount(void * jarg1) {
38797   int jresult ;
38798   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38799   int result;
38800
38801   arg1 = (Dali::Animation *)jarg1;
38802   {
38803     try {
38804       result = (int)(arg1)->GetLoopCount();
38805     } catch (std::out_of_range& e) {
38806       {
38807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38808       };
38809     } catch (std::exception& e) {
38810       {
38811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38812       };
38813     } catch (...) {
38814       {
38815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38816       };
38817     }
38818   }
38819   jresult = result;
38820   return jresult;
38821 }
38822
38823
38824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetCurrentLoop(void * jarg1) {
38825   int jresult ;
38826   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38827   int result;
38828
38829   arg1 = (Dali::Animation *)jarg1;
38830   {
38831     try {
38832       result = (int)(arg1)->GetCurrentLoop();
38833     } catch (std::out_of_range& e) {
38834       {
38835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38836       };
38837     } catch (std::exception& e) {
38838       {
38839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38840       };
38841     } catch (...) {
38842       {
38843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38844       };
38845     }
38846   }
38847   jresult = result;
38848   return jresult;
38849 }
38850
38851
38852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Animation_IsLooping(void * jarg1) {
38853   unsigned int jresult ;
38854   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38855   bool result;
38856
38857   arg1 = (Dali::Animation *)jarg1;
38858   {
38859     try {
38860       result = (bool)((Dali::Animation const *)arg1)->IsLooping();
38861     } catch (std::out_of_range& e) {
38862       {
38863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38864       };
38865     } catch (std::exception& e) {
38866       {
38867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38868       };
38869     } catch (...) {
38870       {
38871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38872       };
38873     }
38874   }
38875   jresult = result;
38876   return jresult;
38877 }
38878
38879
38880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetEndAction(void * jarg1, int jarg2) {
38881   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38882   Dali::Animation::EndAction arg2 ;
38883
38884   arg1 = (Dali::Animation *)jarg1;
38885   arg2 = (Dali::Animation::EndAction)jarg2;
38886   {
38887     try {
38888       (arg1)->SetEndAction(arg2);
38889     } catch (std::out_of_range& e) {
38890       {
38891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38892       };
38893     } catch (std::exception& e) {
38894       {
38895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38896       };
38897     } catch (...) {
38898       {
38899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38900       };
38901     }
38902   }
38903 }
38904
38905
38906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetEndAction(void * jarg1) {
38907   int jresult ;
38908   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38909   Dali::Animation::EndAction result;
38910
38911   arg1 = (Dali::Animation *)jarg1;
38912   {
38913     try {
38914       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetEndAction();
38915     } catch (std::out_of_range& e) {
38916       {
38917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38918       };
38919     } catch (std::exception& e) {
38920       {
38921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38922       };
38923     } catch (...) {
38924       {
38925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38926       };
38927     }
38928   }
38929   jresult = (int)result;
38930   return jresult;
38931 }
38932
38933
38934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDisconnectAction(void * jarg1, int jarg2) {
38935   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38936   Dali::Animation::EndAction arg2 ;
38937
38938   arg1 = (Dali::Animation *)jarg1;
38939   arg2 = (Dali::Animation::EndAction)jarg2;
38940   {
38941     try {
38942       (arg1)->SetDisconnectAction(arg2);
38943     } catch (std::out_of_range& e) {
38944       {
38945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38946       };
38947     } catch (std::exception& e) {
38948       {
38949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38950       };
38951     } catch (...) {
38952       {
38953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38954       };
38955     }
38956   }
38957 }
38958
38959
38960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetDisconnectAction(void * jarg1) {
38961   int jresult ;
38962   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38963   Dali::Animation::EndAction result;
38964
38965   arg1 = (Dali::Animation *)jarg1;
38966   {
38967     try {
38968       result = (Dali::Animation::EndAction)((Dali::Animation const *)arg1)->GetDisconnectAction();
38969     } catch (std::out_of_range& e) {
38970       {
38971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38972       };
38973     } catch (std::exception& e) {
38974       {
38975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38976       };
38977     } catch (...) {
38978       {
38979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38980       };
38981     }
38982   }
38983   jresult = (int)result;
38984   return jresult;
38985 }
38986
38987
38988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetDefaultAlphaFunction(void * jarg1, void * jarg2) {
38989   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
38990   Dali::AlphaFunction arg2 ;
38991   Dali::AlphaFunction *argp2 ;
38992
38993   arg1 = (Dali::Animation *)jarg1;
38994   argp2 = (Dali::AlphaFunction *)jarg2;
38995   if (!argp2) {
38996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
38997     return ;
38998   }
38999   arg2 = *argp2;
39000   {
39001     try {
39002       (arg1)->SetDefaultAlphaFunction(arg2);
39003     } catch (std::out_of_range& e) {
39004       {
39005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39006       };
39007     } catch (std::exception& e) {
39008       {
39009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39010       };
39011     } catch (...) {
39012       {
39013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39014       };
39015     }
39016   }
39017 }
39018
39019
39020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetDefaultAlphaFunction(void * jarg1) {
39021   void * jresult ;
39022   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39023   Dali::AlphaFunction result;
39024
39025   arg1 = (Dali::Animation *)jarg1;
39026   {
39027     try {
39028       result = ((Dali::Animation const *)arg1)->GetDefaultAlphaFunction();
39029     } catch (std::out_of_range& e) {
39030       {
39031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39032       };
39033     } catch (std::exception& e) {
39034       {
39035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39036       };
39037     } catch (...) {
39038       {
39039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39040       };
39041     }
39042   }
39043   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
39044   return jresult;
39045 }
39046
39047
39048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetCurrentProgress(void * jarg1, float jarg2) {
39049   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39050   float arg2 ;
39051
39052   arg1 = (Dali::Animation *)jarg1;
39053   arg2 = (float)jarg2;
39054   {
39055     try {
39056       (arg1)->SetCurrentProgress(arg2);
39057     } catch (std::out_of_range& e) {
39058       {
39059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39060       };
39061     } catch (std::exception& e) {
39062       {
39063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39064       };
39065     } catch (...) {
39066       {
39067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39068       };
39069     }
39070   }
39071 }
39072
39073
39074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetCurrentProgress(void * jarg1) {
39075   float jresult ;
39076   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39077   float result;
39078
39079   arg1 = (Dali::Animation *)jarg1;
39080   {
39081     try {
39082       result = (float)(arg1)->GetCurrentProgress();
39083     } catch (std::out_of_range& e) {
39084       {
39085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39086       };
39087     } catch (std::exception& e) {
39088       {
39089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39090       };
39091     } catch (...) {
39092       {
39093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39094       };
39095     }
39096   }
39097   jresult = result;
39098   return jresult;
39099 }
39100
39101
39102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetSpeedFactor(void * jarg1, float jarg2) {
39103   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39104   float arg2 ;
39105
39106   arg1 = (Dali::Animation *)jarg1;
39107   arg2 = (float)jarg2;
39108   {
39109     try {
39110       (arg1)->SetSpeedFactor(arg2);
39111     } catch (std::out_of_range& e) {
39112       {
39113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39114       };
39115     } catch (std::exception& e) {
39116       {
39117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39118       };
39119     } catch (...) {
39120       {
39121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39122       };
39123     }
39124   }
39125 }
39126
39127
39128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Animation_GetSpeedFactor(void * jarg1) {
39129   float jresult ;
39130   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39131   float result;
39132
39133   arg1 = (Dali::Animation *)jarg1;
39134   {
39135     try {
39136       result = (float)((Dali::Animation const *)arg1)->GetSpeedFactor();
39137     } catch (std::out_of_range& e) {
39138       {
39139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39140       };
39141     } catch (std::exception& e) {
39142       {
39143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39144       };
39145     } catch (...) {
39146       {
39147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39148       };
39149     }
39150   }
39151   jresult = result;
39152   return jresult;
39153 }
39154
39155
39156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_SetPlayRange(void * jarg1, void * jarg2) {
39157   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39158   Dali::Vector2 *arg2 = 0 ;
39159
39160   arg1 = (Dali::Animation *)jarg1;
39161   arg2 = (Dali::Vector2 *)jarg2;
39162   if (!arg2) {
39163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39164     return ;
39165   }
39166   {
39167     try {
39168       (arg1)->SetPlayRange((Dali::Vector2 const &)*arg2);
39169     } catch (std::out_of_range& e) {
39170       {
39171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39172       };
39173     } catch (std::exception& e) {
39174       {
39175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39176       };
39177     } catch (...) {
39178       {
39179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39180       };
39181     }
39182   }
39183 }
39184
39185
39186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_GetPlayRange(void * jarg1) {
39187   void * jresult ;
39188   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39189   Dali::Vector2 result;
39190
39191   arg1 = (Dali::Animation *)jarg1;
39192   {
39193     try {
39194       result = ((Dali::Animation const *)arg1)->GetPlayRange();
39195     } catch (std::out_of_range& e) {
39196       {
39197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39198       };
39199     } catch (std::exception& e) {
39200       {
39201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39202       };
39203     } catch (...) {
39204       {
39205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39206       };
39207     }
39208   }
39209   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
39210   return jresult;
39211 }
39212
39213
39214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Play(void * jarg1) {
39215   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39216
39217   arg1 = (Dali::Animation *)jarg1;
39218   {
39219     try {
39220       (arg1)->Play();
39221     } catch (std::out_of_range& e) {
39222       {
39223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39224       };
39225     } catch (std::exception& e) {
39226       {
39227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39228       };
39229     } catch (...) {
39230       {
39231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39232       };
39233     }
39234   }
39235 }
39236
39237
39238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_PlayFrom(void * jarg1, float jarg2) {
39239   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39240   float arg2 ;
39241
39242   arg1 = (Dali::Animation *)jarg1;
39243   arg2 = (float)jarg2;
39244   {
39245     try {
39246       (arg1)->PlayFrom(arg2);
39247     } catch (std::out_of_range& e) {
39248       {
39249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39250       };
39251     } catch (std::exception& e) {
39252       {
39253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39254       };
39255     } catch (...) {
39256       {
39257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39258       };
39259     }
39260   }
39261 }
39262
39263
39264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Pause(void * jarg1) {
39265   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39266
39267   arg1 = (Dali::Animation *)jarg1;
39268   {
39269     try {
39270       (arg1)->Pause();
39271     } catch (std::out_of_range& e) {
39272       {
39273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39274       };
39275     } catch (std::exception& e) {
39276       {
39277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39278       };
39279     } catch (...) {
39280       {
39281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39282       };
39283     }
39284   }
39285 }
39286
39287
39288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Animation_GetState(void * jarg1) {
39289   int jresult ;
39290   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39291   Dali::Animation::State result;
39292
39293   arg1 = (Dali::Animation *)jarg1;
39294   {
39295     try {
39296       result = (Dali::Animation::State)((Dali::Animation const *)arg1)->GetState();
39297     } catch (std::out_of_range& e) {
39298       {
39299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39300       };
39301     } catch (std::exception& e) {
39302       {
39303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39304       };
39305     } catch (...) {
39306       {
39307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39308       };
39309     }
39310   }
39311   jresult = (int)result;
39312   return jresult;
39313 }
39314
39315
39316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Stop(void * jarg1) {
39317   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39318
39319   arg1 = (Dali::Animation *)jarg1;
39320   {
39321     try {
39322       (arg1)->Stop();
39323     } catch (std::out_of_range& e) {
39324       {
39325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39326       };
39327     } catch (std::exception& e) {
39328       {
39329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39330       };
39331     } catch (...) {
39332       {
39333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39334       };
39335     }
39336   }
39337 }
39338
39339
39340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Clear(void * jarg1) {
39341   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39342
39343   arg1 = (Dali::Animation *)jarg1;
39344   {
39345     try {
39346       (arg1)->Clear();
39347     } catch (std::out_of_range& e) {
39348       {
39349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39350       };
39351     } catch (std::exception& e) {
39352       {
39353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39354       };
39355     } catch (...) {
39356       {
39357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39358       };
39359     }
39360   }
39361 }
39362
39363
39364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Animation_FinishedSignal(void * jarg1) {
39365   void * jresult ;
39366   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39367   Dali::Animation::AnimationSignalType *result = 0 ;
39368
39369   arg1 = (Dali::Animation *)jarg1;
39370   {
39371     try {
39372       result = (Dali::Animation::AnimationSignalType *) &(arg1)->FinishedSignal();
39373     } catch (std::out_of_range& e) {
39374       {
39375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39376       };
39377     } catch (std::exception& e) {
39378       {
39379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39380       };
39381     } catch (...) {
39382       {
39383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39384       };
39385     }
39386   }
39387   jresult = (void *)result;
39388   return jresult;
39389 }
39390
39391
39392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39393   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39394   SwigValueWrapper< Dali::Property > arg2 ;
39395   Dali::Property::Value arg3 ;
39396   Dali::Property *argp2 ;
39397   Dali::Property::Value *argp3 ;
39398
39399   arg1 = (Dali::Animation *)jarg1;
39400   argp2 = (Dali::Property *)jarg2;
39401   if (!argp2) {
39402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39403     return ;
39404   }
39405   arg2 = *argp2;
39406   argp3 = (Dali::Property::Value *)jarg3;
39407   if (!argp3) {
39408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39409     return ;
39410   }
39411   arg3 = *argp3;
39412   {
39413     try {
39414       (arg1)->AnimateBy(arg2,arg3);
39415     } catch (std::out_of_range& e) {
39416       {
39417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39418       };
39419     } catch (std::exception& e) {
39420       {
39421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39422       };
39423     } catch (...) {
39424       {
39425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39426       };
39427     }
39428   }
39429 }
39430
39431
39432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39433   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39434   SwigValueWrapper< Dali::Property > arg2 ;
39435   Dali::Property::Value arg3 ;
39436   Dali::AlphaFunction arg4 ;
39437   Dali::Property *argp2 ;
39438   Dali::Property::Value *argp3 ;
39439   Dali::AlphaFunction *argp4 ;
39440
39441   arg1 = (Dali::Animation *)jarg1;
39442   argp2 = (Dali::Property *)jarg2;
39443   if (!argp2) {
39444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39445     return ;
39446   }
39447   arg2 = *argp2;
39448   argp3 = (Dali::Property::Value *)jarg3;
39449   if (!argp3) {
39450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39451     return ;
39452   }
39453   arg3 = *argp3;
39454   argp4 = (Dali::AlphaFunction *)jarg4;
39455   if (!argp4) {
39456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39457     return ;
39458   }
39459   arg4 = *argp4;
39460   {
39461     try {
39462       (arg1)->AnimateBy(arg2,arg3,arg4);
39463     } catch (std::out_of_range& e) {
39464       {
39465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39466       };
39467     } catch (std::exception& e) {
39468       {
39469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39470       };
39471     } catch (...) {
39472       {
39473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39474       };
39475     }
39476   }
39477 }
39478
39479
39480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39481   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39482   SwigValueWrapper< Dali::Property > arg2 ;
39483   Dali::Property::Value arg3 ;
39484   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39485   Dali::Property *argp2 ;
39486   Dali::Property::Value *argp3 ;
39487   Dali::TimePeriod *argp4 ;
39488
39489   arg1 = (Dali::Animation *)jarg1;
39490   argp2 = (Dali::Property *)jarg2;
39491   if (!argp2) {
39492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39493     return ;
39494   }
39495   arg2 = *argp2;
39496   argp3 = (Dali::Property::Value *)jarg3;
39497   if (!argp3) {
39498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39499     return ;
39500   }
39501   arg3 = *argp3;
39502   argp4 = (Dali::TimePeriod *)jarg4;
39503   if (!argp4) {
39504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39505     return ;
39506   }
39507   arg4 = *argp4;
39508   {
39509     try {
39510       (arg1)->AnimateBy(arg2,arg3,arg4);
39511     } catch (std::out_of_range& e) {
39512       {
39513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39514       };
39515     } catch (std::exception& e) {
39516       {
39517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39518       };
39519     } catch (...) {
39520       {
39521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39522       };
39523     }
39524   }
39525 }
39526
39527
39528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBy__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39529   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39530   SwigValueWrapper< Dali::Property > arg2 ;
39531   Dali::Property::Value arg3 ;
39532   Dali::AlphaFunction arg4 ;
39533   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39534   Dali::Property *argp2 ;
39535   Dali::Property::Value *argp3 ;
39536   Dali::AlphaFunction *argp4 ;
39537   Dali::TimePeriod *argp5 ;
39538
39539   arg1 = (Dali::Animation *)jarg1;
39540   argp2 = (Dali::Property *)jarg2;
39541   if (!argp2) {
39542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39543     return ;
39544   }
39545   arg2 = *argp2;
39546   argp3 = (Dali::Property::Value *)jarg3;
39547   if (!argp3) {
39548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39549     return ;
39550   }
39551   arg3 = *argp3;
39552   argp4 = (Dali::AlphaFunction *)jarg4;
39553   if (!argp4) {
39554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39555     return ;
39556   }
39557   arg4 = *argp4;
39558   argp5 = (Dali::TimePeriod *)jarg5;
39559   if (!argp5) {
39560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39561     return ;
39562   }
39563   arg5 = *argp5;
39564   {
39565     try {
39566       (arg1)->AnimateBy(arg2,arg3,arg4,arg5);
39567     } catch (std::out_of_range& e) {
39568       {
39569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39570       };
39571     } catch (std::exception& e) {
39572       {
39573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39574       };
39575     } catch (...) {
39576       {
39577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39578       };
39579     }
39580   }
39581 }
39582
39583
39584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39585   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39586   SwigValueWrapper< Dali::Property > arg2 ;
39587   Dali::Property::Value arg3 ;
39588   Dali::Property *argp2 ;
39589   Dali::Property::Value *argp3 ;
39590
39591   arg1 = (Dali::Animation *)jarg1;
39592   argp2 = (Dali::Property *)jarg2;
39593   if (!argp2) {
39594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39595     return ;
39596   }
39597   arg2 = *argp2;
39598   argp3 = (Dali::Property::Value *)jarg3;
39599   if (!argp3) {
39600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39601     return ;
39602   }
39603   arg3 = *argp3;
39604   {
39605     try {
39606       (arg1)->AnimateTo(arg2,arg3);
39607     } catch (std::out_of_range& e) {
39608       {
39609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39610       };
39611     } catch (std::exception& e) {
39612       {
39613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39614       };
39615     } catch (...) {
39616       {
39617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39618       };
39619     }
39620   }
39621 }
39622
39623
39624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39625   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39626   SwigValueWrapper< Dali::Property > arg2 ;
39627   Dali::Property::Value arg3 ;
39628   Dali::AlphaFunction arg4 ;
39629   Dali::Property *argp2 ;
39630   Dali::Property::Value *argp3 ;
39631   Dali::AlphaFunction *argp4 ;
39632
39633   arg1 = (Dali::Animation *)jarg1;
39634   argp2 = (Dali::Property *)jarg2;
39635   if (!argp2) {
39636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39637     return ;
39638   }
39639   arg2 = *argp2;
39640   argp3 = (Dali::Property::Value *)jarg3;
39641   if (!argp3) {
39642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39643     return ;
39644   }
39645   arg3 = *argp3;
39646   argp4 = (Dali::AlphaFunction *)jarg4;
39647   if (!argp4) {
39648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39649     return ;
39650   }
39651   arg4 = *argp4;
39652   {
39653     try {
39654       (arg1)->AnimateTo(arg2,arg3,arg4);
39655     } catch (std::out_of_range& e) {
39656       {
39657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39658       };
39659     } catch (std::exception& e) {
39660       {
39661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39662       };
39663     } catch (...) {
39664       {
39665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39666       };
39667     }
39668   }
39669 }
39670
39671
39672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39673   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39674   SwigValueWrapper< Dali::Property > arg2 ;
39675   Dali::Property::Value arg3 ;
39676   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39677   Dali::Property *argp2 ;
39678   Dali::Property::Value *argp3 ;
39679   Dali::TimePeriod *argp4 ;
39680
39681   arg1 = (Dali::Animation *)jarg1;
39682   argp2 = (Dali::Property *)jarg2;
39683   if (!argp2) {
39684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39685     return ;
39686   }
39687   arg2 = *argp2;
39688   argp3 = (Dali::Property::Value *)jarg3;
39689   if (!argp3) {
39690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39691     return ;
39692   }
39693   arg3 = *argp3;
39694   argp4 = (Dali::TimePeriod *)jarg4;
39695   if (!argp4) {
39696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39697     return ;
39698   }
39699   arg4 = *argp4;
39700   {
39701     try {
39702       (arg1)->AnimateTo(arg2,arg3,arg4);
39703     } catch (std::out_of_range& e) {
39704       {
39705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39706       };
39707     } catch (std::exception& e) {
39708       {
39709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39710       };
39711     } catch (...) {
39712       {
39713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39714       };
39715     }
39716   }
39717 }
39718
39719
39720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateTo__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
39721   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39722   SwigValueWrapper< Dali::Property > arg2 ;
39723   Dali::Property::Value arg3 ;
39724   Dali::AlphaFunction arg4 ;
39725   SwigValueWrapper< Dali::TimePeriod > arg5 ;
39726   Dali::Property *argp2 ;
39727   Dali::Property::Value *argp3 ;
39728   Dali::AlphaFunction *argp4 ;
39729   Dali::TimePeriod *argp5 ;
39730
39731   arg1 = (Dali::Animation *)jarg1;
39732   argp2 = (Dali::Property *)jarg2;
39733   if (!argp2) {
39734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39735     return ;
39736   }
39737   arg2 = *argp2;
39738   argp3 = (Dali::Property::Value *)jarg3;
39739   if (!argp3) {
39740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39741     return ;
39742   }
39743   arg3 = *argp3;
39744   argp4 = (Dali::AlphaFunction *)jarg4;
39745   if (!argp4) {
39746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39747     return ;
39748   }
39749   arg4 = *argp4;
39750   argp5 = (Dali::TimePeriod *)jarg5;
39751   if (!argp5) {
39752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39753     return ;
39754   }
39755   arg5 = *argp5;
39756   {
39757     try {
39758       (arg1)->AnimateTo(arg2,arg3,arg4,arg5);
39759     } catch (std::out_of_range& e) {
39760       {
39761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39762       };
39763     } catch (std::exception& e) {
39764       {
39765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39766       };
39767     } catch (...) {
39768       {
39769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39770       };
39771     }
39772   }
39773 }
39774
39775
39776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
39777   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39778   SwigValueWrapper< Dali::Property > arg2 ;
39779   Dali::KeyFrames *arg3 = 0 ;
39780   Dali::Property *argp2 ;
39781
39782   arg1 = (Dali::Animation *)jarg1;
39783   argp2 = (Dali::Property *)jarg2;
39784   if (!argp2) {
39785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39786     return ;
39787   }
39788   arg2 = *argp2;
39789   arg3 = (Dali::KeyFrames *)jarg3;
39790   if (!arg3) {
39791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39792     return ;
39793   }
39794   {
39795     try {
39796       (arg1)->AnimateBetween(arg2,*arg3);
39797     } catch (std::out_of_range& e) {
39798       {
39799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39800       };
39801     } catch (std::exception& e) {
39802       {
39803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39804       };
39805     } catch (...) {
39806       {
39807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39808       };
39809     }
39810   }
39811 }
39812
39813
39814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_1(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
39815   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39816   SwigValueWrapper< Dali::Property > arg2 ;
39817   Dali::KeyFrames *arg3 = 0 ;
39818   Dali::Animation::Interpolation arg4 ;
39819   Dali::Property *argp2 ;
39820
39821   arg1 = (Dali::Animation *)jarg1;
39822   argp2 = (Dali::Property *)jarg2;
39823   if (!argp2) {
39824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39825     return ;
39826   }
39827   arg2 = *argp2;
39828   arg3 = (Dali::KeyFrames *)jarg3;
39829   if (!arg3) {
39830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39831     return ;
39832   }
39833   arg4 = (Dali::Animation::Interpolation)jarg4;
39834   {
39835     try {
39836       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39837     } catch (std::out_of_range& e) {
39838       {
39839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39840       };
39841     } catch (std::exception& e) {
39842       {
39843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39844       };
39845     } catch (...) {
39846       {
39847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39848       };
39849     }
39850   }
39851 }
39852
39853
39854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39855   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39856   SwigValueWrapper< Dali::Property > arg2 ;
39857   Dali::KeyFrames *arg3 = 0 ;
39858   Dali::AlphaFunction arg4 ;
39859   Dali::Property *argp2 ;
39860   Dali::AlphaFunction *argp4 ;
39861
39862   arg1 = (Dali::Animation *)jarg1;
39863   argp2 = (Dali::Property *)jarg2;
39864   if (!argp2) {
39865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39866     return ;
39867   }
39868   arg2 = *argp2;
39869   arg3 = (Dali::KeyFrames *)jarg3;
39870   if (!arg3) {
39871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39872     return ;
39873   }
39874   argp4 = (Dali::AlphaFunction *)jarg4;
39875   if (!argp4) {
39876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39877     return ;
39878   }
39879   arg4 = *argp4;
39880   {
39881     try {
39882       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39883     } catch (std::out_of_range& e) {
39884       {
39885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39886       };
39887     } catch (std::exception& e) {
39888       {
39889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39890       };
39891     } catch (...) {
39892       {
39893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39894       };
39895     }
39896   }
39897 }
39898
39899
39900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39901   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39902   SwigValueWrapper< Dali::Property > arg2 ;
39903   Dali::KeyFrames *arg3 = 0 ;
39904   Dali::AlphaFunction arg4 ;
39905   Dali::Animation::Interpolation arg5 ;
39906   Dali::Property *argp2 ;
39907   Dali::AlphaFunction *argp4 ;
39908
39909   arg1 = (Dali::Animation *)jarg1;
39910   argp2 = (Dali::Property *)jarg2;
39911   if (!argp2) {
39912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39913     return ;
39914   }
39915   arg2 = *argp2;
39916   arg3 = (Dali::KeyFrames *)jarg3;
39917   if (!arg3) {
39918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39919     return ;
39920   }
39921   argp4 = (Dali::AlphaFunction *)jarg4;
39922   if (!argp4) {
39923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
39924     return ;
39925   }
39926   arg4 = *argp4;
39927   arg5 = (Dali::Animation::Interpolation)jarg5;
39928   {
39929     try {
39930       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
39931     } catch (std::out_of_range& e) {
39932       {
39933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39934       };
39935     } catch (std::exception& e) {
39936       {
39937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39938       };
39939     } catch (...) {
39940       {
39941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39942       };
39943     }
39944   }
39945 }
39946
39947
39948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_4(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
39949   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39950   SwigValueWrapper< Dali::Property > arg2 ;
39951   Dali::KeyFrames *arg3 = 0 ;
39952   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39953   Dali::Property *argp2 ;
39954   Dali::TimePeriod *argp4 ;
39955
39956   arg1 = (Dali::Animation *)jarg1;
39957   argp2 = (Dali::Property *)jarg2;
39958   if (!argp2) {
39959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
39960     return ;
39961   }
39962   arg2 = *argp2;
39963   arg3 = (Dali::KeyFrames *)jarg3;
39964   if (!arg3) {
39965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
39966     return ;
39967   }
39968   argp4 = (Dali::TimePeriod *)jarg4;
39969   if (!argp4) {
39970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
39971     return ;
39972   }
39973   arg4 = *argp4;
39974   {
39975     try {
39976       (arg1)->AnimateBetween(arg2,*arg3,arg4);
39977     } catch (std::out_of_range& e) {
39978       {
39979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39980       };
39981     } catch (std::exception& e) {
39982       {
39983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39984       };
39985     } catch (...) {
39986       {
39987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39988       };
39989     }
39990   }
39991 }
39992
39993
39994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_5(void * jarg1, void * jarg2, void * jarg3, void * jarg4, int jarg5) {
39995   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
39996   SwigValueWrapper< Dali::Property > arg2 ;
39997   Dali::KeyFrames *arg3 = 0 ;
39998   SwigValueWrapper< Dali::TimePeriod > arg4 ;
39999   Dali::Animation::Interpolation arg5 ;
40000   Dali::Property *argp2 ;
40001   Dali::TimePeriod *argp4 ;
40002
40003   arg1 = (Dali::Animation *)jarg1;
40004   argp2 = (Dali::Property *)jarg2;
40005   if (!argp2) {
40006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40007     return ;
40008   }
40009   arg2 = *argp2;
40010   arg3 = (Dali::KeyFrames *)jarg3;
40011   if (!arg3) {
40012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40013     return ;
40014   }
40015   argp4 = (Dali::TimePeriod *)jarg4;
40016   if (!argp4) {
40017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40018     return ;
40019   }
40020   arg4 = *argp4;
40021   arg5 = (Dali::Animation::Interpolation)jarg5;
40022   {
40023     try {
40024       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40025     } catch (std::out_of_range& e) {
40026       {
40027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40028       };
40029     } catch (std::exception& e) {
40030       {
40031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40032       };
40033     } catch (...) {
40034       {
40035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40036       };
40037     }
40038   }
40039 }
40040
40041
40042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_6(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40043   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40044   SwigValueWrapper< Dali::Property > arg2 ;
40045   Dali::KeyFrames *arg3 = 0 ;
40046   Dali::AlphaFunction arg4 ;
40047   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40048   Dali::Property *argp2 ;
40049   Dali::AlphaFunction *argp4 ;
40050   Dali::TimePeriod *argp5 ;
40051
40052   arg1 = (Dali::Animation *)jarg1;
40053   argp2 = (Dali::Property *)jarg2;
40054   if (!argp2) {
40055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40056     return ;
40057   }
40058   arg2 = *argp2;
40059   arg3 = (Dali::KeyFrames *)jarg3;
40060   if (!arg3) {
40061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40062     return ;
40063   }
40064   argp4 = (Dali::AlphaFunction *)jarg4;
40065   if (!argp4) {
40066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40067     return ;
40068   }
40069   arg4 = *argp4;
40070   argp5 = (Dali::TimePeriod *)jarg5;
40071   if (!argp5) {
40072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40073     return ;
40074   }
40075   arg5 = *argp5;
40076   {
40077     try {
40078       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5);
40079     } catch (std::out_of_range& e) {
40080       {
40081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40082       };
40083     } catch (std::exception& e) {
40084       {
40085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40086       };
40087     } catch (...) {
40088       {
40089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40090       };
40091     }
40092   }
40093 }
40094
40095
40096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_AnimateBetween__SWIG_7(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, int jarg6) {
40097   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40098   SwigValueWrapper< Dali::Property > arg2 ;
40099   Dali::KeyFrames *arg3 = 0 ;
40100   Dali::AlphaFunction arg4 ;
40101   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40102   Dali::Animation::Interpolation arg6 ;
40103   Dali::Property *argp2 ;
40104   Dali::AlphaFunction *argp4 ;
40105   Dali::TimePeriod *argp5 ;
40106
40107   arg1 = (Dali::Animation *)jarg1;
40108   argp2 = (Dali::Property *)jarg2;
40109   if (!argp2) {
40110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40111     return ;
40112   }
40113   arg2 = *argp2;
40114   arg3 = (Dali::KeyFrames *)jarg3;
40115   if (!arg3) {
40116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames & type is null", 0);
40117     return ;
40118   }
40119   argp4 = (Dali::AlphaFunction *)jarg4;
40120   if (!argp4) {
40121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40122     return ;
40123   }
40124   arg4 = *argp4;
40125   argp5 = (Dali::TimePeriod *)jarg5;
40126   if (!argp5) {
40127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40128     return ;
40129   }
40130   arg5 = *argp5;
40131   arg6 = (Dali::Animation::Interpolation)jarg6;
40132   {
40133     try {
40134       (arg1)->AnimateBetween(arg2,*arg3,arg4,arg5,arg6);
40135     } catch (std::out_of_range& e) {
40136       {
40137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40138       };
40139     } catch (std::exception& e) {
40140       {
40141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40142       };
40143     } catch (...) {
40144       {
40145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40146       };
40147     }
40148   }
40149 }
40150
40151
40152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40153   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40154   Dali::Actor arg2 ;
40155   Dali::Path arg3 ;
40156   Dali::Vector3 *arg4 = 0 ;
40157   Dali::Actor *argp2 ;
40158   Dali::Path *argp3 ;
40159
40160   arg1 = (Dali::Animation *)jarg1;
40161   argp2 = (Dali::Actor *)jarg2;
40162   if (!argp2) {
40163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40164     return ;
40165   }
40166   arg2 = *argp2;
40167   argp3 = (Dali::Path *)jarg3;
40168   if (!argp3) {
40169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40170     return ;
40171   }
40172   arg3 = *argp3;
40173   arg4 = (Dali::Vector3 *)jarg4;
40174   if (!arg4) {
40175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40176     return ;
40177   }
40178   {
40179     try {
40180       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4);
40181     } catch (std::out_of_range& e) {
40182       {
40183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40184       };
40185     } catch (std::exception& e) {
40186       {
40187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40188       };
40189     } catch (...) {
40190       {
40191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40192       };
40193     }
40194   }
40195 }
40196
40197
40198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40199   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40200   Dali::Actor arg2 ;
40201   Dali::Path arg3 ;
40202   Dali::Vector3 *arg4 = 0 ;
40203   Dali::AlphaFunction arg5 ;
40204   Dali::Actor *argp2 ;
40205   Dali::Path *argp3 ;
40206   Dali::AlphaFunction *argp5 ;
40207
40208   arg1 = (Dali::Animation *)jarg1;
40209   argp2 = (Dali::Actor *)jarg2;
40210   if (!argp2) {
40211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40212     return ;
40213   }
40214   arg2 = *argp2;
40215   argp3 = (Dali::Path *)jarg3;
40216   if (!argp3) {
40217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40218     return ;
40219   }
40220   arg3 = *argp3;
40221   arg4 = (Dali::Vector3 *)jarg4;
40222   if (!arg4) {
40223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40224     return ;
40225   }
40226   argp5 = (Dali::AlphaFunction *)jarg5;
40227   if (!argp5) {
40228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40229     return ;
40230   }
40231   arg5 = *argp5;
40232   {
40233     try {
40234       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40235     } catch (std::out_of_range& e) {
40236       {
40237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40238       };
40239     } catch (std::exception& e) {
40240       {
40241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40242       };
40243     } catch (...) {
40244       {
40245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40246       };
40247     }
40248   }
40249 }
40250
40251
40252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_2(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40253   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40254   Dali::Actor arg2 ;
40255   Dali::Path arg3 ;
40256   Dali::Vector3 *arg4 = 0 ;
40257   SwigValueWrapper< Dali::TimePeriod > arg5 ;
40258   Dali::Actor *argp2 ;
40259   Dali::Path *argp3 ;
40260   Dali::TimePeriod *argp5 ;
40261
40262   arg1 = (Dali::Animation *)jarg1;
40263   argp2 = (Dali::Actor *)jarg2;
40264   if (!argp2) {
40265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40266     return ;
40267   }
40268   arg2 = *argp2;
40269   argp3 = (Dali::Path *)jarg3;
40270   if (!argp3) {
40271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40272     return ;
40273   }
40274   arg3 = *argp3;
40275   arg4 = (Dali::Vector3 *)jarg4;
40276   if (!arg4) {
40277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40278     return ;
40279   }
40280   argp5 = (Dali::TimePeriod *)jarg5;
40281   if (!argp5) {
40282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40283     return ;
40284   }
40285   arg5 = *argp5;
40286   {
40287     try {
40288       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
40289     } catch (std::out_of_range& e) {
40290       {
40291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40292       };
40293     } catch (std::exception& e) {
40294       {
40295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40296       };
40297     } catch (...) {
40298       {
40299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40300       };
40301     }
40302   }
40303 }
40304
40305
40306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Animate__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5, void * jarg6) {
40307   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40308   Dali::Actor arg2 ;
40309   Dali::Path arg3 ;
40310   Dali::Vector3 *arg4 = 0 ;
40311   Dali::AlphaFunction arg5 ;
40312   SwigValueWrapper< Dali::TimePeriod > arg6 ;
40313   Dali::Actor *argp2 ;
40314   Dali::Path *argp3 ;
40315   Dali::AlphaFunction *argp5 ;
40316   Dali::TimePeriod *argp6 ;
40317
40318   arg1 = (Dali::Animation *)jarg1;
40319   argp2 = (Dali::Actor *)jarg2;
40320   if (!argp2) {
40321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40322     return ;
40323   }
40324   arg2 = *argp2;
40325   argp3 = (Dali::Path *)jarg3;
40326   if (!argp3) {
40327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
40328     return ;
40329   }
40330   arg3 = *argp3;
40331   arg4 = (Dali::Vector3 *)jarg4;
40332   if (!arg4) {
40333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
40334     return ;
40335   }
40336   argp5 = (Dali::AlphaFunction *)jarg5;
40337   if (!argp5) {
40338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
40339     return ;
40340   }
40341   arg5 = *argp5;
40342   argp6 = (Dali::TimePeriod *)jarg6;
40343   if (!argp6) {
40344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::TimePeriod", 0);
40345     return ;
40346   }
40347   arg6 = *argp6;
40348   {
40349     try {
40350       (arg1)->Animate(arg2,arg3,(Dali::Vector3 const &)*arg4,arg5,arg6);
40351     } catch (std::out_of_range& e) {
40352       {
40353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40354       };
40355     } catch (std::exception& e) {
40356       {
40357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40358       };
40359     } catch (...) {
40360       {
40361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40362       };
40363     }
40364   }
40365 }
40366
40367
40368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Show(void * jarg1, void * jarg2, float jarg3) {
40369   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40370   Dali::Actor arg2 ;
40371   float arg3 ;
40372   Dali::Actor *argp2 ;
40373
40374   arg1 = (Dali::Animation *)jarg1;
40375   argp2 = (Dali::Actor *)jarg2;
40376   if (!argp2) {
40377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40378     return ;
40379   }
40380   arg2 = *argp2;
40381   arg3 = (float)jarg3;
40382   {
40383     try {
40384       (arg1)->Show(arg2,arg3);
40385     } catch (std::out_of_range& e) {
40386       {
40387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40388       };
40389     } catch (std::exception& e) {
40390       {
40391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40392       };
40393     } catch (...) {
40394       {
40395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40396       };
40397     }
40398   }
40399 }
40400
40401
40402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Animation_Hide(void * jarg1, void * jarg2, float jarg3) {
40403   Dali::Animation *arg1 = (Dali::Animation *) 0 ;
40404   Dali::Actor arg2 ;
40405   float arg3 ;
40406   Dali::Actor *argp2 ;
40407
40408   arg1 = (Dali::Animation *)jarg1;
40409   argp2 = (Dali::Actor *)jarg2;
40410   if (!argp2) {
40411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
40412     return ;
40413   }
40414   arg2 = *argp2;
40415   arg3 = (float)jarg3;
40416   {
40417     try {
40418       (arg1)->Hide(arg2,arg3);
40419     } catch (std::out_of_range& e) {
40420       {
40421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40422       };
40423     } catch (std::exception& e) {
40424       {
40425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40426       };
40427     } catch (...) {
40428       {
40429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40430       };
40431     }
40432   }
40433 }
40434
40435
40436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
40437   int jresult ;
40438   int result;
40439
40440   result = (int)Dali::LinearConstrainer::Property::VALUE;
40441   jresult = (int)result;
40442   return jresult;
40443 }
40444
40445
40446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
40447   int jresult ;
40448   int result;
40449
40450   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
40451   jresult = (int)result;
40452   return jresult;
40453 }
40454
40455
40456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
40457   void * jresult ;
40458   Dali::LinearConstrainer::Property *result = 0 ;
40459
40460   {
40461     try {
40462       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
40463     } catch (std::out_of_range& e) {
40464       {
40465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40466       };
40467     } catch (std::exception& e) {
40468       {
40469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40470       };
40471     } catch (...) {
40472       {
40473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40474       };
40475     }
40476   }
40477   jresult = (void *)result;
40478   return jresult;
40479 }
40480
40481
40482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
40483   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
40484
40485   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
40486   {
40487     try {
40488       delete arg1;
40489     } catch (std::out_of_range& e) {
40490       {
40491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40492       };
40493     } catch (std::exception& e) {
40494       {
40495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40496       };
40497     } catch (...) {
40498       {
40499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40500       };
40501     }
40502   }
40503 }
40504
40505
40506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
40507   void * jresult ;
40508   Dali::LinearConstrainer result;
40509
40510   {
40511     try {
40512       result = Dali::LinearConstrainer::New();
40513     } catch (std::out_of_range& e) {
40514       {
40515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40516       };
40517     } catch (std::exception& e) {
40518       {
40519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40520       };
40521     } catch (...) {
40522       {
40523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40524       };
40525     }
40526   }
40527   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40528   return jresult;
40529 }
40530
40531
40532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
40533   void * jresult ;
40534   Dali::BaseHandle arg1 ;
40535   Dali::BaseHandle *argp1 ;
40536   Dali::LinearConstrainer result;
40537
40538   argp1 = (Dali::BaseHandle *)jarg1;
40539   if (!argp1) {
40540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40541     return 0;
40542   }
40543   arg1 = *argp1;
40544   {
40545     try {
40546       result = Dali::LinearConstrainer::DownCast(arg1);
40547     } catch (std::out_of_range& e) {
40548       {
40549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40550       };
40551     } catch (std::exception& e) {
40552       {
40553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40554       };
40555     } catch (...) {
40556       {
40557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40558       };
40559     }
40560   }
40561   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
40562   return jresult;
40563 }
40564
40565
40566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
40567   void * jresult ;
40568   Dali::LinearConstrainer *result = 0 ;
40569
40570   {
40571     try {
40572       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
40573     } catch (std::out_of_range& e) {
40574       {
40575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40576       };
40577     } catch (std::exception& e) {
40578       {
40579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40580       };
40581     } catch (...) {
40582       {
40583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40584       };
40585     }
40586   }
40587   jresult = (void *)result;
40588   return jresult;
40589 }
40590
40591
40592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
40593   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40594
40595   arg1 = (Dali::LinearConstrainer *)jarg1;
40596   {
40597     try {
40598       delete arg1;
40599     } catch (std::out_of_range& e) {
40600       {
40601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40602       };
40603     } catch (std::exception& e) {
40604       {
40605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40606       };
40607     } catch (...) {
40608       {
40609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40610       };
40611     }
40612   }
40613 }
40614
40615
40616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
40617   void * jresult ;
40618   Dali::LinearConstrainer *arg1 = 0 ;
40619   Dali::LinearConstrainer *result = 0 ;
40620
40621   arg1 = (Dali::LinearConstrainer *)jarg1;
40622   if (!arg1) {
40623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40624     return 0;
40625   }
40626   {
40627     try {
40628       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
40629     } catch (std::out_of_range& e) {
40630       {
40631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40632       };
40633     } catch (std::exception& e) {
40634       {
40635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40636       };
40637     } catch (...) {
40638       {
40639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40640       };
40641     }
40642   }
40643   jresult = (void *)result;
40644   return jresult;
40645 }
40646
40647
40648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
40649   void * jresult ;
40650   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40651   Dali::LinearConstrainer *arg2 = 0 ;
40652   Dali::LinearConstrainer *result = 0 ;
40653
40654   arg1 = (Dali::LinearConstrainer *)jarg1;
40655   arg2 = (Dali::LinearConstrainer *)jarg2;
40656   if (!arg2) {
40657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
40658     return 0;
40659   }
40660   {
40661     try {
40662       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
40663     } catch (std::out_of_range& e) {
40664       {
40665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40666       };
40667     } catch (std::exception& e) {
40668       {
40669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40670       };
40671     } catch (...) {
40672       {
40673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40674       };
40675     }
40676   }
40677   jresult = (void *)result;
40678   return jresult;
40679 }
40680
40681
40682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
40683   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40684   SwigValueWrapper< Dali::Property > arg2 ;
40685   SwigValueWrapper< Dali::Property > arg3 ;
40686   Dali::Vector2 *arg4 = 0 ;
40687   Dali::Vector2 *arg5 = 0 ;
40688   Dali::Property *argp2 ;
40689   Dali::Property *argp3 ;
40690
40691   arg1 = (Dali::LinearConstrainer *)jarg1;
40692   argp2 = (Dali::Property *)jarg2;
40693   if (!argp2) {
40694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40695     return ;
40696   }
40697   arg2 = *argp2;
40698   argp3 = (Dali::Property *)jarg3;
40699   if (!argp3) {
40700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40701     return ;
40702   }
40703   arg3 = *argp3;
40704   arg4 = (Dali::Vector2 *)jarg4;
40705   if (!arg4) {
40706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40707     return ;
40708   }
40709   arg5 = (Dali::Vector2 *)jarg5;
40710   if (!arg5) {
40711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40712     return ;
40713   }
40714   {
40715     try {
40716       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
40717     } catch (std::out_of_range& e) {
40718       {
40719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40720       };
40721     } catch (std::exception& e) {
40722       {
40723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40724       };
40725     } catch (...) {
40726       {
40727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40728       };
40729     }
40730   }
40731 }
40732
40733
40734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
40735   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40736   SwigValueWrapper< Dali::Property > arg2 ;
40737   SwigValueWrapper< Dali::Property > arg3 ;
40738   Dali::Vector2 *arg4 = 0 ;
40739   Dali::Property *argp2 ;
40740   Dali::Property *argp3 ;
40741
40742   arg1 = (Dali::LinearConstrainer *)jarg1;
40743   argp2 = (Dali::Property *)jarg2;
40744   if (!argp2) {
40745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40746     return ;
40747   }
40748   arg2 = *argp2;
40749   argp3 = (Dali::Property *)jarg3;
40750   if (!argp3) {
40751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
40752     return ;
40753   }
40754   arg3 = *argp3;
40755   arg4 = (Dali::Vector2 *)jarg4;
40756   if (!arg4) {
40757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
40758     return ;
40759   }
40760   {
40761     try {
40762       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
40763     } catch (std::out_of_range& e) {
40764       {
40765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40766       };
40767     } catch (std::exception& e) {
40768       {
40769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40770       };
40771     } catch (...) {
40772       {
40773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40774       };
40775     }
40776   }
40777 }
40778
40779
40780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
40781   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
40782   Dali::Handle *arg2 = 0 ;
40783
40784   arg1 = (Dali::LinearConstrainer *)jarg1;
40785   arg2 = (Dali::Handle *)jarg2;
40786   if (!arg2) {
40787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
40788     return ;
40789   }
40790   {
40791     try {
40792       (arg1)->Remove(*arg2);
40793     } catch (std::out_of_range& e) {
40794       {
40795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40796       };
40797     } catch (std::exception& e) {
40798       {
40799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40800       };
40801     } catch (...) {
40802       {
40803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40804       };
40805     }
40806   }
40807 }
40808
40809
40810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
40811   int jresult ;
40812   int result;
40813
40814   result = (int)Dali::PathConstrainer::Property::FORWARD;
40815   jresult = (int)result;
40816   return jresult;
40817 }
40818
40819
40820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
40821   int jresult ;
40822   int result;
40823
40824   result = (int)Dali::PathConstrainer::Property::POINTS;
40825   jresult = (int)result;
40826   return jresult;
40827 }
40828
40829
40830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
40831   int jresult ;
40832   int result;
40833
40834   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
40835   jresult = (int)result;
40836   return jresult;
40837 }
40838
40839
40840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
40841   void * jresult ;
40842   Dali::PathConstrainer::Property *result = 0 ;
40843
40844   {
40845     try {
40846       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
40847     } catch (std::out_of_range& e) {
40848       {
40849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40850       };
40851     } catch (std::exception& e) {
40852       {
40853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40854       };
40855     } catch (...) {
40856       {
40857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40858       };
40859     }
40860   }
40861   jresult = (void *)result;
40862   return jresult;
40863 }
40864
40865
40866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
40867   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
40868
40869   arg1 = (Dali::PathConstrainer::Property *)jarg1;
40870   {
40871     try {
40872       delete arg1;
40873     } catch (std::out_of_range& e) {
40874       {
40875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40876       };
40877     } catch (std::exception& e) {
40878       {
40879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40880       };
40881     } catch (...) {
40882       {
40883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40884       };
40885     }
40886   }
40887 }
40888
40889
40890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
40891   void * jresult ;
40892   Dali::PathConstrainer result;
40893
40894   {
40895     try {
40896       result = Dali::PathConstrainer::New();
40897     } catch (std::out_of_range& e) {
40898       {
40899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40900       };
40901     } catch (std::exception& e) {
40902       {
40903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40904       };
40905     } catch (...) {
40906       {
40907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40908       };
40909     }
40910   }
40911   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40912   return jresult;
40913 }
40914
40915
40916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
40917   void * jresult ;
40918   Dali::BaseHandle arg1 ;
40919   Dali::BaseHandle *argp1 ;
40920   Dali::PathConstrainer result;
40921
40922   argp1 = (Dali::BaseHandle *)jarg1;
40923   if (!argp1) {
40924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40925     return 0;
40926   }
40927   arg1 = *argp1;
40928   {
40929     try {
40930       result = Dali::PathConstrainer::DownCast(arg1);
40931     } catch (std::out_of_range& e) {
40932       {
40933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40934       };
40935     } catch (std::exception& e) {
40936       {
40937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40938       };
40939     } catch (...) {
40940       {
40941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40942       };
40943     }
40944   }
40945   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
40946   return jresult;
40947 }
40948
40949
40950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
40951   void * jresult ;
40952   Dali::PathConstrainer *result = 0 ;
40953
40954   {
40955     try {
40956       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
40957     } catch (std::out_of_range& e) {
40958       {
40959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40960       };
40961     } catch (std::exception& e) {
40962       {
40963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40964       };
40965     } catch (...) {
40966       {
40967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40968       };
40969     }
40970   }
40971   jresult = (void *)result;
40972   return jresult;
40973 }
40974
40975
40976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
40977   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
40978
40979   arg1 = (Dali::PathConstrainer *)jarg1;
40980   {
40981     try {
40982       delete arg1;
40983     } catch (std::out_of_range& e) {
40984       {
40985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40986       };
40987     } catch (std::exception& e) {
40988       {
40989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40990       };
40991     } catch (...) {
40992       {
40993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40994       };
40995     }
40996   }
40997 }
40998
40999
41000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
41001   void * jresult ;
41002   Dali::PathConstrainer *arg1 = 0 ;
41003   Dali::PathConstrainer *result = 0 ;
41004
41005   arg1 = (Dali::PathConstrainer *)jarg1;
41006   if (!arg1) {
41007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41008     return 0;
41009   }
41010   {
41011     try {
41012       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
41013     } catch (std::out_of_range& e) {
41014       {
41015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41016       };
41017     } catch (std::exception& e) {
41018       {
41019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41020       };
41021     } catch (...) {
41022       {
41023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41024       };
41025     }
41026   }
41027   jresult = (void *)result;
41028   return jresult;
41029 }
41030
41031
41032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
41033   void * jresult ;
41034   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41035   Dali::PathConstrainer *arg2 = 0 ;
41036   Dali::PathConstrainer *result = 0 ;
41037
41038   arg1 = (Dali::PathConstrainer *)jarg1;
41039   arg2 = (Dali::PathConstrainer *)jarg2;
41040   if (!arg2) {
41041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
41042     return 0;
41043   }
41044   {
41045     try {
41046       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
41047     } catch (std::out_of_range& e) {
41048       {
41049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41050       };
41051     } catch (std::exception& e) {
41052       {
41053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41054       };
41055     } catch (...) {
41056       {
41057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41058       };
41059     }
41060   }
41061   jresult = (void *)result;
41062   return jresult;
41063 }
41064
41065
41066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
41067   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41068   SwigValueWrapper< Dali::Property > arg2 ;
41069   SwigValueWrapper< Dali::Property > arg3 ;
41070   Dali::Vector2 *arg4 = 0 ;
41071   Dali::Vector2 *arg5 = 0 ;
41072   Dali::Property *argp2 ;
41073   Dali::Property *argp3 ;
41074
41075   arg1 = (Dali::PathConstrainer *)jarg1;
41076   argp2 = (Dali::Property *)jarg2;
41077   if (!argp2) {
41078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41079     return ;
41080   }
41081   arg2 = *argp2;
41082   argp3 = (Dali::Property *)jarg3;
41083   if (!argp3) {
41084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41085     return ;
41086   }
41087   arg3 = *argp3;
41088   arg4 = (Dali::Vector2 *)jarg4;
41089   if (!arg4) {
41090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41091     return ;
41092   }
41093   arg5 = (Dali::Vector2 *)jarg5;
41094   if (!arg5) {
41095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41096     return ;
41097   }
41098   {
41099     try {
41100       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
41101     } catch (std::out_of_range& e) {
41102       {
41103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41104       };
41105     } catch (std::exception& e) {
41106       {
41107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41108       };
41109     } catch (...) {
41110       {
41111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41112       };
41113     }
41114   }
41115 }
41116
41117
41118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
41119   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41120   SwigValueWrapper< Dali::Property > arg2 ;
41121   SwigValueWrapper< Dali::Property > arg3 ;
41122   Dali::Vector2 *arg4 = 0 ;
41123   Dali::Property *argp2 ;
41124   Dali::Property *argp3 ;
41125
41126   arg1 = (Dali::PathConstrainer *)jarg1;
41127   argp2 = (Dali::Property *)jarg2;
41128   if (!argp2) {
41129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41130     return ;
41131   }
41132   arg2 = *argp2;
41133   argp3 = (Dali::Property *)jarg3;
41134   if (!argp3) {
41135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
41136     return ;
41137   }
41138   arg3 = *argp3;
41139   arg4 = (Dali::Vector2 *)jarg4;
41140   if (!arg4) {
41141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
41142     return ;
41143   }
41144   {
41145     try {
41146       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
41147     } catch (std::out_of_range& e) {
41148       {
41149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41150       };
41151     } catch (std::exception& e) {
41152       {
41153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41154       };
41155     } catch (...) {
41156       {
41157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41158       };
41159     }
41160   }
41161 }
41162
41163
41164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
41165   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
41166   Dali::Handle *arg2 = 0 ;
41167
41168   arg1 = (Dali::PathConstrainer *)jarg1;
41169   arg2 = (Dali::Handle *)jarg2;
41170   if (!arg2) {
41171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
41172     return ;
41173   }
41174   {
41175     try {
41176       (arg1)->Remove(*arg2);
41177     } catch (std::out_of_range& e) {
41178       {
41179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41180       };
41181     } catch (std::exception& e) {
41182       {
41183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41184       };
41185     } catch (...) {
41186       {
41187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41188       };
41189     }
41190   }
41191 }
41192
41193
41194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
41195   int jresult ;
41196   Dali::FittingMode::Type result;
41197
41198   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
41199   jresult = (int)result;
41200   return jresult;
41201 }
41202
41203
41204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
41205   int jresult ;
41206   Dali::SamplingMode::Type result;
41207
41208   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
41209   jresult = (int)result;
41210   return jresult;
41211 }
41212
41213
41214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
41215   void * jresult ;
41216   Dali::BufferImage *result = 0 ;
41217
41218   {
41219     try {
41220       result = (Dali::BufferImage *)new Dali::BufferImage();
41221     } catch (std::out_of_range& e) {
41222       {
41223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41224       };
41225     } catch (std::exception& e) {
41226       {
41227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41228       };
41229     } catch (...) {
41230       {
41231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41232       };
41233     }
41234   }
41235   jresult = (void *)result;
41236   return jresult;
41237 }
41238
41239
41240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
41241   void * jresult ;
41242   unsigned int arg1 ;
41243   unsigned int arg2 ;
41244   Dali::Pixel::Format arg3 ;
41245   Dali::BufferImage result;
41246
41247   arg1 = (unsigned int)jarg1;
41248   arg2 = (unsigned int)jarg2;
41249   arg3 = (Dali::Pixel::Format)jarg3;
41250   {
41251     try {
41252       result = Dali::BufferImage::New(arg1,arg2,arg3);
41253     } catch (std::out_of_range& e) {
41254       {
41255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41256       };
41257     } catch (std::exception& e) {
41258       {
41259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41260       };
41261     } catch (...) {
41262       {
41263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41264       };
41265     }
41266   }
41267   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41268   return jresult;
41269 }
41270
41271
41272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
41273   void * jresult ;
41274   unsigned int arg1 ;
41275   unsigned int arg2 ;
41276   Dali::BufferImage result;
41277
41278   arg1 = (unsigned int)jarg1;
41279   arg2 = (unsigned int)jarg2;
41280   {
41281     try {
41282       result = Dali::BufferImage::New(arg1,arg2);
41283     } catch (std::out_of_range& e) {
41284       {
41285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41286       };
41287     } catch (std::exception& e) {
41288       {
41289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41290       };
41291     } catch (...) {
41292       {
41293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41294       };
41295     }
41296   }
41297   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41298   return jresult;
41299 }
41300
41301
41302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
41303   void * jresult ;
41304   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41305   unsigned int arg2 ;
41306   unsigned int arg3 ;
41307   Dali::Pixel::Format arg4 ;
41308   unsigned int arg5 ;
41309   Dali::BufferImage result;
41310
41311   arg1 = jarg1;
41312   arg2 = (unsigned int)jarg2;
41313   arg3 = (unsigned int)jarg3;
41314   arg4 = (Dali::Pixel::Format)jarg4;
41315   arg5 = (unsigned int)jarg5;
41316   {
41317     try {
41318       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
41319     } catch (std::out_of_range& e) {
41320       {
41321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41322       };
41323     } catch (std::exception& e) {
41324       {
41325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41326       };
41327     } catch (...) {
41328       {
41329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41330       };
41331     }
41332   }
41333   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41334
41335
41336   return jresult;
41337 }
41338
41339
41340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
41341   void * jresult ;
41342   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41343   unsigned int arg2 ;
41344   unsigned int arg3 ;
41345   Dali::Pixel::Format arg4 ;
41346   Dali::BufferImage result;
41347
41348   arg1 = jarg1;
41349   arg2 = (unsigned int)jarg2;
41350   arg3 = (unsigned int)jarg3;
41351   arg4 = (Dali::Pixel::Format)jarg4;
41352   {
41353     try {
41354       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
41355     } catch (std::out_of_range& e) {
41356       {
41357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41358       };
41359     } catch (std::exception& e) {
41360       {
41361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41362       };
41363     } catch (...) {
41364       {
41365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41366       };
41367     }
41368   }
41369   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41370
41371
41372   return jresult;
41373 }
41374
41375
41376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
41377   void * jresult ;
41378   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
41379   unsigned int arg2 ;
41380   unsigned int arg3 ;
41381   Dali::BufferImage result;
41382
41383   arg1 = jarg1;
41384   arg2 = (unsigned int)jarg2;
41385   arg3 = (unsigned int)jarg3;
41386   {
41387     try {
41388       result = Dali::BufferImage::New(arg1,arg2,arg3);
41389     } catch (std::out_of_range& e) {
41390       {
41391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41392       };
41393     } catch (std::exception& e) {
41394       {
41395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41396       };
41397     } catch (...) {
41398       {
41399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41400       };
41401     }
41402   }
41403   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41404
41405
41406   return jresult;
41407 }
41408
41409
41410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
41411   void * jresult ;
41412   Dali::BaseHandle arg1 ;
41413   Dali::BaseHandle *argp1 ;
41414   Dali::BufferImage result;
41415
41416   argp1 = (Dali::BaseHandle *)jarg1;
41417   if (!argp1) {
41418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41419     return 0;
41420   }
41421   arg1 = *argp1;
41422   {
41423     try {
41424       result = Dali::BufferImage::DownCast(arg1);
41425     } catch (std::out_of_range& e) {
41426       {
41427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41428       };
41429     } catch (std::exception& e) {
41430       {
41431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41432       };
41433     } catch (...) {
41434       {
41435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41436       };
41437     }
41438   }
41439   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41440   return jresult;
41441 }
41442
41443
41444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
41445   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41446
41447   arg1 = (Dali::BufferImage *)jarg1;
41448   {
41449     try {
41450       delete arg1;
41451     } catch (std::out_of_range& e) {
41452       {
41453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41454       };
41455     } catch (std::exception& e) {
41456       {
41457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41458       };
41459     } catch (...) {
41460       {
41461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41462       };
41463     }
41464   }
41465 }
41466
41467
41468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
41469   void * jresult ;
41470   Dali::BufferImage *arg1 = 0 ;
41471   Dali::BufferImage *result = 0 ;
41472
41473   arg1 = (Dali::BufferImage *)jarg1;
41474   if (!arg1) {
41475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41476     return 0;
41477   }
41478   {
41479     try {
41480       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
41481     } catch (std::out_of_range& e) {
41482       {
41483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41484       };
41485     } catch (std::exception& e) {
41486       {
41487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41488       };
41489     } catch (...) {
41490       {
41491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41492       };
41493     }
41494   }
41495   jresult = (void *)result;
41496   return jresult;
41497 }
41498
41499
41500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
41501   void * jresult ;
41502   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41503   Dali::BufferImage *arg2 = 0 ;
41504   Dali::BufferImage *result = 0 ;
41505
41506   arg1 = (Dali::BufferImage *)jarg1;
41507   arg2 = (Dali::BufferImage *)jarg2;
41508   if (!arg2) {
41509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
41510     return 0;
41511   }
41512   {
41513     try {
41514       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
41515     } catch (std::out_of_range& e) {
41516       {
41517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41518       };
41519     } catch (std::exception& e) {
41520       {
41521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41522       };
41523     } catch (...) {
41524       {
41525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41526       };
41527     }
41528   }
41529   jresult = (void *)result;
41530   return jresult;
41531 }
41532
41533
41534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
41535   void * jresult ;
41536   Dali::BufferImage result;
41537
41538   {
41539     try {
41540       result = Dali::BufferImage::WHITE();
41541     } catch (std::out_of_range& e) {
41542       {
41543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41544       };
41545     } catch (std::exception& e) {
41546       {
41547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41548       };
41549     } catch (...) {
41550       {
41551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41552       };
41553     }
41554   }
41555   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
41556   return jresult;
41557 }
41558
41559
41560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
41561   void * jresult ;
41562   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41563   Dali::PixelBuffer *result = 0 ;
41564
41565   arg1 = (Dali::BufferImage *)jarg1;
41566   {
41567     try {
41568       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
41569     } catch (std::out_of_range& e) {
41570       {
41571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41572       };
41573     } catch (std::exception& e) {
41574       {
41575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41576       };
41577     } catch (...) {
41578       {
41579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41580       };
41581     }
41582   }
41583   jresult = (void *)result;
41584   return jresult;
41585 }
41586
41587
41588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
41589   unsigned int jresult ;
41590   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41591   unsigned int result;
41592
41593   arg1 = (Dali::BufferImage *)jarg1;
41594   {
41595     try {
41596       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
41597     } catch (std::out_of_range& e) {
41598       {
41599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41600       };
41601     } catch (std::exception& e) {
41602       {
41603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41604       };
41605     } catch (...) {
41606       {
41607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41608       };
41609     }
41610   }
41611   jresult = result;
41612   return jresult;
41613 }
41614
41615
41616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
41617   unsigned int jresult ;
41618   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41619   unsigned int result;
41620
41621   arg1 = (Dali::BufferImage *)jarg1;
41622   {
41623     try {
41624       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
41625     } catch (std::out_of_range& e) {
41626       {
41627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41628       };
41629     } catch (std::exception& e) {
41630       {
41631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41632       };
41633     } catch (...) {
41634       {
41635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41636       };
41637     }
41638   }
41639   jresult = result;
41640   return jresult;
41641 }
41642
41643
41644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
41645   int jresult ;
41646   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41647   Dali::Pixel::Format result;
41648
41649   arg1 = (Dali::BufferImage *)jarg1;
41650   {
41651     try {
41652       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
41653     } catch (std::out_of_range& e) {
41654       {
41655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41656       };
41657     } catch (std::exception& e) {
41658       {
41659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41660       };
41661     } catch (...) {
41662       {
41663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41664       };
41665     }
41666   }
41667   jresult = (int)result;
41668   return jresult;
41669 }
41670
41671
41672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
41673   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41674
41675   arg1 = (Dali::BufferImage *)jarg1;
41676   {
41677     try {
41678       (arg1)->Update();
41679     } catch (std::out_of_range& e) {
41680       {
41681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41682       };
41683     } catch (std::exception& e) {
41684       {
41685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41686       };
41687     } catch (...) {
41688       {
41689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41690       };
41691     }
41692   }
41693 }
41694
41695
41696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
41697   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41698   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
41699   Dali::RectArea *argp2 ;
41700
41701   arg1 = (Dali::BufferImage *)jarg1;
41702   argp2 = (Dali::RectArea *)jarg2;
41703   if (!argp2) {
41704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
41705     return ;
41706   }
41707   arg2 = *argp2;
41708   {
41709     try {
41710       (arg1)->Update(arg2);
41711     } catch (std::out_of_range& e) {
41712       {
41713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41714       };
41715     } catch (std::exception& e) {
41716       {
41717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41718       };
41719     } catch (...) {
41720       {
41721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41722       };
41723     }
41724   }
41725 }
41726
41727
41728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
41729   unsigned int jresult ;
41730   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
41731   bool result;
41732
41733   arg1 = (Dali::BufferImage *)jarg1;
41734   {
41735     try {
41736       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
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 = result;
41752   return jresult;
41753 }
41754
41755
41756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
41757   void * jresult ;
41758   Dali::EncodedBufferImage *result = 0 ;
41759
41760   {
41761     try {
41762       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
41763     } catch (std::out_of_range& e) {
41764       {
41765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41766       };
41767     } catch (std::exception& e) {
41768       {
41769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41770       };
41771     } catch (...) {
41772       {
41773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41774       };
41775     }
41776   }
41777   jresult = (void *)result;
41778   return jresult;
41779 }
41780
41781
41782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
41783   void * jresult ;
41784   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41785   std::size_t arg2 ;
41786   Dali::EncodedBufferImage result;
41787
41788   arg1 = (uint8_t *)jarg1;
41789   arg2 = (std::size_t)jarg2;
41790   {
41791     try {
41792       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
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 = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41808   return jresult;
41809 }
41810
41811
41812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
41813   void * jresult ;
41814   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41815   std::size_t arg2 ;
41816   Dali::ImageDimensions arg3 ;
41817   Dali::FittingMode::Type arg4 ;
41818   Dali::SamplingMode::Type arg5 ;
41819   bool arg6 ;
41820   Dali::ImageDimensions *argp3 ;
41821   Dali::EncodedBufferImage result;
41822
41823   arg1 = (uint8_t *)jarg1;
41824   arg2 = (std::size_t)jarg2;
41825   argp3 = (Dali::ImageDimensions *)jarg3;
41826   if (!argp3) {
41827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41828     return 0;
41829   }
41830   arg3 = *argp3;
41831   arg4 = (Dali::FittingMode::Type)jarg4;
41832   arg5 = (Dali::SamplingMode::Type)jarg5;
41833   arg6 = jarg6 ? true : false;
41834   {
41835     try {
41836       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
41837     } catch (std::out_of_range& e) {
41838       {
41839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41840       };
41841     } catch (std::exception& e) {
41842       {
41843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41844       };
41845     } catch (...) {
41846       {
41847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41848       };
41849     }
41850   }
41851   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41852   return jresult;
41853 }
41854
41855
41856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
41857   void * jresult ;
41858   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
41859   std::size_t arg2 ;
41860   Dali::ImageDimensions arg3 ;
41861   Dali::FittingMode::Type arg4 ;
41862   Dali::SamplingMode::Type arg5 ;
41863   Dali::ImageDimensions *argp3 ;
41864   Dali::EncodedBufferImage result;
41865
41866   arg1 = (uint8_t *)jarg1;
41867   arg2 = (std::size_t)jarg2;
41868   argp3 = (Dali::ImageDimensions *)jarg3;
41869   if (!argp3) {
41870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
41871     return 0;
41872   }
41873   arg3 = *argp3;
41874   arg4 = (Dali::FittingMode::Type)jarg4;
41875   arg5 = (Dali::SamplingMode::Type)jarg5;
41876   {
41877     try {
41878       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
41879     } catch (std::out_of_range& e) {
41880       {
41881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41882       };
41883     } catch (std::exception& e) {
41884       {
41885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41886       };
41887     } catch (...) {
41888       {
41889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41890       };
41891     }
41892   }
41893   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41894   return jresult;
41895 }
41896
41897
41898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
41899   void * jresult ;
41900   Dali::BaseHandle arg1 ;
41901   Dali::BaseHandle *argp1 ;
41902   Dali::EncodedBufferImage result;
41903
41904   argp1 = (Dali::BaseHandle *)jarg1;
41905   if (!argp1) {
41906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41907     return 0;
41908   }
41909   arg1 = *argp1;
41910   {
41911     try {
41912       result = Dali::EncodedBufferImage::DownCast(arg1);
41913     } catch (std::out_of_range& e) {
41914       {
41915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41916       };
41917     } catch (std::exception& e) {
41918       {
41919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41920       };
41921     } catch (...) {
41922       {
41923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41924       };
41925     }
41926   }
41927   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
41928   return jresult;
41929 }
41930
41931
41932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
41933   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41934
41935   arg1 = (Dali::EncodedBufferImage *)jarg1;
41936   {
41937     try {
41938       delete arg1;
41939     } catch (std::out_of_range& e) {
41940       {
41941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41942       };
41943     } catch (std::exception& e) {
41944       {
41945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41946       };
41947     } catch (...) {
41948       {
41949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41950       };
41951     }
41952   }
41953 }
41954
41955
41956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
41957   void * jresult ;
41958   Dali::EncodedBufferImage *arg1 = 0 ;
41959   Dali::EncodedBufferImage *result = 0 ;
41960
41961   arg1 = (Dali::EncodedBufferImage *)jarg1;
41962   if (!arg1) {
41963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41964     return 0;
41965   }
41966   {
41967     try {
41968       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
41969     } catch (std::out_of_range& e) {
41970       {
41971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41972       };
41973     } catch (std::exception& e) {
41974       {
41975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41976       };
41977     } catch (...) {
41978       {
41979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41980       };
41981     }
41982   }
41983   jresult = (void *)result;
41984   return jresult;
41985 }
41986
41987
41988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
41989   void * jresult ;
41990   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
41991   Dali::EncodedBufferImage *arg2 = 0 ;
41992   Dali::EncodedBufferImage *result = 0 ;
41993
41994   arg1 = (Dali::EncodedBufferImage *)jarg1;
41995   arg2 = (Dali::EncodedBufferImage *)jarg2;
41996   if (!arg2) {
41997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
41998     return 0;
41999   }
42000   {
42001     try {
42002       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
42003     } catch (std::out_of_range& e) {
42004       {
42005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42006       };
42007     } catch (std::exception& e) {
42008       {
42009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42010       };
42011     } catch (...) {
42012       {
42013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42014       };
42015     }
42016   }
42017   jresult = (void *)result;
42018   return jresult;
42019 }
42020
42021
42022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
42023   void * jresult ;
42024   Dali::NativeImage *result = 0 ;
42025
42026   {
42027     try {
42028       result = (Dali::NativeImage *)new Dali::NativeImage();
42029     } catch (std::out_of_range& e) {
42030       {
42031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42032       };
42033     } catch (std::exception& e) {
42034       {
42035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42036       };
42037     } catch (...) {
42038       {
42039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42040       };
42041     }
42042   }
42043   jresult = (void *)result;
42044   return jresult;
42045 }
42046
42047
42048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
42049   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42050
42051   arg1 = (Dali::NativeImage *)jarg1;
42052   {
42053     try {
42054       delete arg1;
42055     } catch (std::out_of_range& e) {
42056       {
42057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42058       };
42059     } catch (std::exception& e) {
42060       {
42061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42062       };
42063     } catch (...) {
42064       {
42065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42066       };
42067     }
42068   }
42069 }
42070
42071
42072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
42073   void * jresult ;
42074   Dali::NativeImage *arg1 = 0 ;
42075   Dali::NativeImage *result = 0 ;
42076
42077   arg1 = (Dali::NativeImage *)jarg1;
42078   if (!arg1) {
42079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42080     return 0;
42081   }
42082   {
42083     try {
42084       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
42085     } catch (std::out_of_range& e) {
42086       {
42087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42088       };
42089     } catch (std::exception& e) {
42090       {
42091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42092       };
42093     } catch (...) {
42094       {
42095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42096       };
42097     }
42098   }
42099   jresult = (void *)result;
42100   return jresult;
42101 }
42102
42103
42104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
42105   void * jresult ;
42106   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42107   Dali::NativeImage *arg2 = 0 ;
42108   Dali::NativeImage *result = 0 ;
42109
42110   arg1 = (Dali::NativeImage *)jarg1;
42111   arg2 = (Dali::NativeImage *)jarg2;
42112   if (!arg2) {
42113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
42114     return 0;
42115   }
42116   {
42117     try {
42118       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
42119     } catch (std::out_of_range& e) {
42120       {
42121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42122       };
42123     } catch (std::exception& e) {
42124       {
42125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42126       };
42127     } catch (...) {
42128       {
42129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42130       };
42131     }
42132   }
42133   jresult = (void *)result;
42134   return jresult;
42135 }
42136
42137
42138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
42139   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42140
42141   arg1 = (Dali::NativeImage *)jarg1;
42142   {
42143     try {
42144       (arg1)->CreateGlTexture();
42145     } catch (std::out_of_range& e) {
42146       {
42147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42148       };
42149     } catch (std::exception& e) {
42150       {
42151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42152       };
42153     } catch (...) {
42154       {
42155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42156       };
42157     }
42158   }
42159 }
42160
42161
42162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
42163   void * jresult ;
42164   NativeImageInterface *arg1 = 0 ;
42165   Dali::NativeImage result;
42166
42167   arg1 = (NativeImageInterface *)jarg1;
42168   if (!arg1) {
42169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
42170     return 0;
42171   }
42172   {
42173     try {
42174       result = Dali::NativeImage::New(*arg1);
42175     } catch (std::out_of_range& e) {
42176       {
42177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42178       };
42179     } catch (std::exception& e) {
42180       {
42181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42182       };
42183     } catch (...) {
42184       {
42185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42186       };
42187     }
42188   }
42189   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42190   return jresult;
42191 }
42192
42193
42194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
42195   void * jresult ;
42196   Dali::BaseHandle arg1 ;
42197   Dali::BaseHandle *argp1 ;
42198   Dali::NativeImage result;
42199
42200   argp1 = (Dali::BaseHandle *)jarg1;
42201   if (!argp1) {
42202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42203     return 0;
42204   }
42205   arg1 = *argp1;
42206   {
42207     try {
42208       result = Dali::NativeImage::DownCast(arg1);
42209     } catch (std::out_of_range& e) {
42210       {
42211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42212       };
42213     } catch (std::exception& e) {
42214       {
42215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42216       };
42217     } catch (...) {
42218       {
42219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42220       };
42221     }
42222   }
42223   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
42224   return jresult;
42225 }
42226
42227
42228 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
42229   char * jresult ;
42230   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42231   char *result = 0 ;
42232
42233   arg1 = (Dali::NativeImage *)jarg1;
42234   {
42235     try {
42236       result = (char *)(arg1)->GetCustomFragmentPreFix();
42237     } catch (std::out_of_range& e) {
42238       {
42239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42240       };
42241     } catch (std::exception& e) {
42242       {
42243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42244       };
42245     } catch (...) {
42246       {
42247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42248       };
42249     }
42250   }
42251   jresult = SWIG_csharp_string_callback((const char *)result);
42252   return jresult;
42253 }
42254
42255
42256 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
42257   char * jresult ;
42258   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
42259   char *result = 0 ;
42260
42261   arg1 = (Dali::NativeImage *)jarg1;
42262   {
42263     try {
42264       result = (char *)(arg1)->GetCustomSamplerTypename();
42265     } catch (std::out_of_range& e) {
42266       {
42267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42268       };
42269     } catch (std::exception& e) {
42270       {
42271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42272       };
42273     } catch (...) {
42274       {
42275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42276       };
42277     }
42278   }
42279   jresult = SWIG_csharp_string_callback((const char *)result);
42280   return jresult;
42281 }
42282
42283
42284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
42285   unsigned int jresult ;
42286   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42287   bool result;
42288
42289   arg1 = (Dali::NativeImageInterface *)jarg1;
42290   {
42291     try {
42292       result = (bool)(arg1)->GlExtensionCreate();
42293     } catch (std::out_of_range& e) {
42294       {
42295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42296       };
42297     } catch (std::exception& e) {
42298       {
42299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42300       };
42301     } catch (...) {
42302       {
42303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42304       };
42305     }
42306   }
42307   jresult = result;
42308   return jresult;
42309 }
42310
42311
42312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
42313   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42314
42315   arg1 = (Dali::NativeImageInterface *)jarg1;
42316   {
42317     try {
42318       (arg1)->GlExtensionDestroy();
42319     } catch (std::out_of_range& e) {
42320       {
42321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42322       };
42323     } catch (std::exception& e) {
42324       {
42325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42326       };
42327     } catch (...) {
42328       {
42329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42330       };
42331     }
42332   }
42333 }
42334
42335
42336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
42337   unsigned int jresult ;
42338   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42339   unsigned int result;
42340
42341   arg1 = (Dali::NativeImageInterface *)jarg1;
42342   {
42343     try {
42344       result = (unsigned int)(arg1)->TargetTexture();
42345     } catch (std::out_of_range& e) {
42346       {
42347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42348       };
42349     } catch (std::exception& e) {
42350       {
42351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42352       };
42353     } catch (...) {
42354       {
42355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42356       };
42357     }
42358   }
42359   jresult = result;
42360   return jresult;
42361 }
42362
42363
42364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
42365   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42366
42367   arg1 = (Dali::NativeImageInterface *)jarg1;
42368   {
42369     try {
42370       (arg1)->PrepareTexture();
42371     } catch (std::out_of_range& e) {
42372       {
42373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42374       };
42375     } catch (std::exception& e) {
42376       {
42377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42378       };
42379     } catch (...) {
42380       {
42381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42382       };
42383     }
42384   }
42385 }
42386
42387
42388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
42389   unsigned int jresult ;
42390   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42391   unsigned int result;
42392
42393   arg1 = (Dali::NativeImageInterface *)jarg1;
42394   {
42395     try {
42396       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
42397     } catch (std::out_of_range& e) {
42398       {
42399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42400       };
42401     } catch (std::exception& e) {
42402       {
42403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42404       };
42405     } catch (...) {
42406       {
42407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42408       };
42409     }
42410   }
42411   jresult = result;
42412   return jresult;
42413 }
42414
42415
42416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
42417   unsigned int jresult ;
42418   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42419   unsigned int result;
42420
42421   arg1 = (Dali::NativeImageInterface *)jarg1;
42422   {
42423     try {
42424       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
42425     } catch (std::out_of_range& e) {
42426       {
42427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42428       };
42429     } catch (std::exception& e) {
42430       {
42431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42432       };
42433     } catch (...) {
42434       {
42435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42436       };
42437     }
42438   }
42439   jresult = result;
42440   return jresult;
42441 }
42442
42443
42444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
42445   unsigned int jresult ;
42446   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
42447   bool result;
42448
42449   arg1 = (Dali::NativeImageInterface *)jarg1;
42450   {
42451     try {
42452       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
42453     } catch (std::out_of_range& e) {
42454       {
42455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42456       };
42457     } catch (std::exception& e) {
42458       {
42459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42460       };
42461     } catch (...) {
42462       {
42463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42464       };
42465     }
42466   }
42467   jresult = result;
42468   return jresult;
42469 }
42470
42471
42472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
42473   void * jresult ;
42474   std::string *arg1 = 0 ;
42475   Dali::ImageDimensions result;
42476
42477   if (!jarg1) {
42478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42479     return 0;
42480   }
42481   std::string arg1_str(jarg1);
42482   arg1 = &arg1_str;
42483   {
42484     try {
42485       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
42486     } catch (std::out_of_range& e) {
42487       {
42488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42489       };
42490     } catch (std::exception& e) {
42491       {
42492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42493       };
42494     } catch (...) {
42495       {
42496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42497       };
42498     }
42499   }
42500   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
42501
42502   //argout typemap for const std::string&
42503
42504   return jresult;
42505 }
42506
42507
42508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
42509   void * jresult ;
42510   Dali::ResourceImage *result = 0 ;
42511
42512   {
42513     try {
42514       result = (Dali::ResourceImage *)new Dali::ResourceImage();
42515     } catch (std::out_of_range& e) {
42516       {
42517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42518       };
42519     } catch (std::exception& e) {
42520       {
42521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42522       };
42523     } catch (...) {
42524       {
42525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42526       };
42527     }
42528   }
42529   jresult = (void *)result;
42530   return jresult;
42531 }
42532
42533
42534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
42535   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42536
42537   arg1 = (Dali::ResourceImage *)jarg1;
42538   {
42539     try {
42540       delete arg1;
42541     } catch (std::out_of_range& e) {
42542       {
42543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42544       };
42545     } catch (std::exception& e) {
42546       {
42547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42548       };
42549     } catch (...) {
42550       {
42551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42552       };
42553     }
42554   }
42555 }
42556
42557
42558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
42559   void * jresult ;
42560   Dali::ResourceImage *arg1 = 0 ;
42561   Dali::ResourceImage *result = 0 ;
42562
42563   arg1 = (Dali::ResourceImage *)jarg1;
42564   if (!arg1) {
42565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42566     return 0;
42567   }
42568   {
42569     try {
42570       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
42571     } catch (std::out_of_range& e) {
42572       {
42573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42574       };
42575     } catch (std::exception& e) {
42576       {
42577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42578       };
42579     } catch (...) {
42580       {
42581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42582       };
42583     }
42584   }
42585   jresult = (void *)result;
42586   return jresult;
42587 }
42588
42589
42590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
42591   void * jresult ;
42592   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42593   Dali::ResourceImage *arg2 = 0 ;
42594   Dali::ResourceImage *result = 0 ;
42595
42596   arg1 = (Dali::ResourceImage *)jarg1;
42597   arg2 = (Dali::ResourceImage *)jarg2;
42598   if (!arg2) {
42599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
42600     return 0;
42601   }
42602   {
42603     try {
42604       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
42605     } catch (std::out_of_range& e) {
42606       {
42607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42608       };
42609     } catch (std::exception& e) {
42610       {
42611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42612       };
42613     } catch (...) {
42614       {
42615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42616       };
42617     }
42618   }
42619   jresult = (void *)result;
42620   return jresult;
42621 }
42622
42623
42624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
42625   void * jresult ;
42626   std::string *arg1 = 0 ;
42627   bool arg2 ;
42628   Dali::ResourceImage result;
42629
42630   if (!jarg1) {
42631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42632     return 0;
42633   }
42634   std::string arg1_str(jarg1);
42635   arg1 = &arg1_str;
42636   arg2 = jarg2 ? true : false;
42637   {
42638     try {
42639       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42640     } catch (std::out_of_range& e) {
42641       {
42642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42643       };
42644     } catch (std::exception& e) {
42645       {
42646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42647       };
42648     } catch (...) {
42649       {
42650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42651       };
42652     }
42653   }
42654   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42655
42656   //argout typemap for const std::string&
42657
42658   return jresult;
42659 }
42660
42661
42662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
42663   void * jresult ;
42664   std::string *arg1 = 0 ;
42665   Dali::ResourceImage result;
42666
42667   if (!jarg1) {
42668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42669     return 0;
42670   }
42671   std::string arg1_str(jarg1);
42672   arg1 = &arg1_str;
42673   {
42674     try {
42675       result = Dali::ResourceImage::New((std::string const &)*arg1);
42676     } catch (std::out_of_range& e) {
42677       {
42678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42679       };
42680     } catch (std::exception& e) {
42681       {
42682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42683       };
42684     } catch (...) {
42685       {
42686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42687       };
42688     }
42689   }
42690   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42691
42692   //argout typemap for const std::string&
42693
42694   return jresult;
42695 }
42696
42697
42698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
42699   void * jresult ;
42700   std::string *arg1 = 0 ;
42701   Dali::ImageDimensions arg2 ;
42702   Dali::FittingMode::Type arg3 ;
42703   Dali::SamplingMode::Type arg4 ;
42704   bool arg5 ;
42705   Dali::ImageDimensions *argp2 ;
42706   Dali::ResourceImage result;
42707
42708   if (!jarg1) {
42709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42710     return 0;
42711   }
42712   std::string arg1_str(jarg1);
42713   arg1 = &arg1_str;
42714   argp2 = (Dali::ImageDimensions *)jarg2;
42715   if (!argp2) {
42716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42717     return 0;
42718   }
42719   arg2 = *argp2;
42720   arg3 = (Dali::FittingMode::Type)jarg3;
42721   arg4 = (Dali::SamplingMode::Type)jarg4;
42722   arg5 = jarg5 ? true : false;
42723   {
42724     try {
42725       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
42726     } catch (std::out_of_range& e) {
42727       {
42728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42729       };
42730     } catch (std::exception& e) {
42731       {
42732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42733       };
42734     } catch (...) {
42735       {
42736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42737       };
42738     }
42739   }
42740   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42741
42742   //argout typemap for const std::string&
42743
42744   return jresult;
42745 }
42746
42747
42748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
42749   void * jresult ;
42750   std::string *arg1 = 0 ;
42751   Dali::ImageDimensions arg2 ;
42752   Dali::FittingMode::Type arg3 ;
42753   Dali::SamplingMode::Type arg4 ;
42754   Dali::ImageDimensions *argp2 ;
42755   Dali::ResourceImage result;
42756
42757   if (!jarg1) {
42758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42759     return 0;
42760   }
42761   std::string arg1_str(jarg1);
42762   arg1 = &arg1_str;
42763   argp2 = (Dali::ImageDimensions *)jarg2;
42764   if (!argp2) {
42765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42766     return 0;
42767   }
42768   arg2 = *argp2;
42769   arg3 = (Dali::FittingMode::Type)jarg3;
42770   arg4 = (Dali::SamplingMode::Type)jarg4;
42771   {
42772     try {
42773       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
42774     } catch (std::out_of_range& e) {
42775       {
42776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42777       };
42778     } catch (std::exception& e) {
42779       {
42780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42781       };
42782     } catch (...) {
42783       {
42784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42785       };
42786     }
42787   }
42788   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42789
42790   //argout typemap for const std::string&
42791
42792   return jresult;
42793 }
42794
42795
42796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
42797   void * jresult ;
42798   std::string *arg1 = 0 ;
42799   Dali::ImageDimensions arg2 ;
42800   Dali::FittingMode::Type arg3 ;
42801   Dali::ImageDimensions *argp2 ;
42802   Dali::ResourceImage result;
42803
42804   if (!jarg1) {
42805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42806     return 0;
42807   }
42808   std::string arg1_str(jarg1);
42809   arg1 = &arg1_str;
42810   argp2 = (Dali::ImageDimensions *)jarg2;
42811   if (!argp2) {
42812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42813     return 0;
42814   }
42815   arg2 = *argp2;
42816   arg3 = (Dali::FittingMode::Type)jarg3;
42817   {
42818     try {
42819       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
42820     } catch (std::out_of_range& e) {
42821       {
42822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42823       };
42824     } catch (std::exception& e) {
42825       {
42826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42827       };
42828     } catch (...) {
42829       {
42830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42831       };
42832     }
42833   }
42834   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42835
42836   //argout typemap for const std::string&
42837
42838   return jresult;
42839 }
42840
42841
42842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
42843   void * jresult ;
42844   std::string *arg1 = 0 ;
42845   Dali::ImageDimensions arg2 ;
42846   Dali::ImageDimensions *argp2 ;
42847   Dali::ResourceImage result;
42848
42849   if (!jarg1) {
42850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
42851     return 0;
42852   }
42853   std::string arg1_str(jarg1);
42854   arg1 = &arg1_str;
42855   argp2 = (Dali::ImageDimensions *)jarg2;
42856   if (!argp2) {
42857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
42858     return 0;
42859   }
42860   arg2 = *argp2;
42861   {
42862     try {
42863       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
42864     } catch (std::out_of_range& e) {
42865       {
42866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42867       };
42868     } catch (std::exception& e) {
42869       {
42870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42871       };
42872     } catch (...) {
42873       {
42874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42875       };
42876     }
42877   }
42878   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42879
42880   //argout typemap for const std::string&
42881
42882   return jresult;
42883 }
42884
42885
42886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
42887   void * jresult ;
42888   Dali::BaseHandle arg1 ;
42889   Dali::BaseHandle *argp1 ;
42890   Dali::ResourceImage result;
42891
42892   argp1 = (Dali::BaseHandle *)jarg1;
42893   if (!argp1) {
42894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42895     return 0;
42896   }
42897   arg1 = *argp1;
42898   {
42899     try {
42900       result = Dali::ResourceImage::DownCast(arg1);
42901     } catch (std::out_of_range& e) {
42902       {
42903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42904       };
42905     } catch (std::exception& e) {
42906       {
42907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42908       };
42909     } catch (...) {
42910       {
42911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42912       };
42913     }
42914   }
42915   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
42916   return jresult;
42917 }
42918
42919
42920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
42921   int jresult ;
42922   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42923   Dali::LoadingState result;
42924
42925   arg1 = (Dali::ResourceImage *)jarg1;
42926   {
42927     try {
42928       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
42929     } catch (std::out_of_range& e) {
42930       {
42931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42932       };
42933     } catch (std::exception& e) {
42934       {
42935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42936       };
42937     } catch (...) {
42938       {
42939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42940       };
42941     }
42942   }
42943   jresult = (int)result;
42944   return jresult;
42945 }
42946
42947
42948 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
42949   char * jresult ;
42950   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42951   std::string result;
42952
42953   arg1 = (Dali::ResourceImage *)jarg1;
42954   {
42955     try {
42956       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
42957     } catch (std::out_of_range& e) {
42958       {
42959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42960       };
42961     } catch (std::exception& e) {
42962       {
42963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42964       };
42965     } catch (...) {
42966       {
42967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42968       };
42969     }
42970   }
42971   jresult = SWIG_csharp_string_callback((&result)->c_str());
42972   return jresult;
42973 }
42974
42975
42976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
42977   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
42978
42979   arg1 = (Dali::ResourceImage *)jarg1;
42980   {
42981     try {
42982       (arg1)->Reload();
42983     } catch (std::out_of_range& e) {
42984       {
42985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42986       };
42987     } catch (std::exception& e) {
42988       {
42989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42990       };
42991     } catch (...) {
42992       {
42993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42994       };
42995     }
42996   }
42997 }
42998
42999
43000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
43001   void * jresult ;
43002   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
43003   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
43004
43005   arg1 = (Dali::ResourceImage *)jarg1;
43006   {
43007     try {
43008       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
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 = (void *)result;
43024   return jresult;
43025 }
43026
43027
43028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
43029   void * jresult ;
43030   Dali::FrameBufferImage *result = 0 ;
43031
43032   {
43033     try {
43034       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
43035     } catch (std::out_of_range& e) {
43036       {
43037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43038       };
43039     } catch (std::exception& e) {
43040       {
43041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43042       };
43043     } catch (...) {
43044       {
43045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43046       };
43047     }
43048   }
43049   jresult = (void *)result;
43050   return jresult;
43051 }
43052
43053
43054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
43055   void * jresult ;
43056   unsigned int arg1 ;
43057   unsigned int arg2 ;
43058   Dali::Pixel::Format arg3 ;
43059   Dali::RenderBuffer::Format arg4 ;
43060   Dali::FrameBufferImage result;
43061
43062   arg1 = (unsigned int)jarg1;
43063   arg2 = (unsigned int)jarg2;
43064   arg3 = (Dali::Pixel::Format)jarg3;
43065   arg4 = (Dali::RenderBuffer::Format)jarg4;
43066   {
43067     try {
43068       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
43069     } catch (std::out_of_range& e) {
43070       {
43071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43072       };
43073     } catch (std::exception& e) {
43074       {
43075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43076       };
43077     } catch (...) {
43078       {
43079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43080       };
43081     }
43082   }
43083   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43084   return jresult;
43085 }
43086
43087
43088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
43089   void * jresult ;
43090   unsigned int arg1 ;
43091   unsigned int arg2 ;
43092   Dali::Pixel::Format arg3 ;
43093   Dali::FrameBufferImage result;
43094
43095   arg1 = (unsigned int)jarg1;
43096   arg2 = (unsigned int)jarg2;
43097   arg3 = (Dali::Pixel::Format)jarg3;
43098   {
43099     try {
43100       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
43101     } catch (std::out_of_range& e) {
43102       {
43103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43104       };
43105     } catch (std::exception& e) {
43106       {
43107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43108       };
43109     } catch (...) {
43110       {
43111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43112       };
43113     }
43114   }
43115   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43116   return jresult;
43117 }
43118
43119
43120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
43121   void * jresult ;
43122   unsigned int arg1 ;
43123   unsigned int arg2 ;
43124   Dali::FrameBufferImage result;
43125
43126   arg1 = (unsigned int)jarg1;
43127   arg2 = (unsigned int)jarg2;
43128   {
43129     try {
43130       result = Dali::FrameBufferImage::New(arg1,arg2);
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 = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43146   return jresult;
43147 }
43148
43149
43150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
43151   void * jresult ;
43152   unsigned int arg1 ;
43153   Dali::FrameBufferImage result;
43154
43155   arg1 = (unsigned int)jarg1;
43156   {
43157     try {
43158       result = Dali::FrameBufferImage::New(arg1);
43159     } catch (std::out_of_range& e) {
43160       {
43161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43162       };
43163     } catch (std::exception& e) {
43164       {
43165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43166       };
43167     } catch (...) {
43168       {
43169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43170       };
43171     }
43172   }
43173   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43174   return jresult;
43175 }
43176
43177
43178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
43179   void * jresult ;
43180   Dali::FrameBufferImage result;
43181
43182   {
43183     try {
43184       result = Dali::FrameBufferImage::New();
43185     } catch (std::out_of_range& e) {
43186       {
43187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43188       };
43189     } catch (std::exception& e) {
43190       {
43191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43192       };
43193     } catch (...) {
43194       {
43195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43196       };
43197     }
43198   }
43199   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43200   return jresult;
43201 }
43202
43203
43204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
43205   void * jresult ;
43206   Dali::NativeImageInterface *arg1 = 0 ;
43207   Dali::FrameBufferImage result;
43208
43209   arg1 = (Dali::NativeImageInterface *)jarg1;
43210   if (!arg1) {
43211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
43212     return 0;
43213   }
43214   {
43215     try {
43216       result = Dali::FrameBufferImage::New(*arg1);
43217     } catch (std::out_of_range& e) {
43218       {
43219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43220       };
43221     } catch (std::exception& e) {
43222       {
43223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43224       };
43225     } catch (...) {
43226       {
43227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43228       };
43229     }
43230   }
43231   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43232   return jresult;
43233 }
43234
43235
43236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
43237   void * jresult ;
43238   Dali::BaseHandle arg1 ;
43239   Dali::BaseHandle *argp1 ;
43240   Dali::FrameBufferImage result;
43241
43242   argp1 = (Dali::BaseHandle *)jarg1;
43243   if (!argp1) {
43244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43245     return 0;
43246   }
43247   arg1 = *argp1;
43248   {
43249     try {
43250       result = Dali::FrameBufferImage::DownCast(arg1);
43251     } catch (std::out_of_range& e) {
43252       {
43253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43254       };
43255     } catch (std::exception& e) {
43256       {
43257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43258       };
43259     } catch (...) {
43260       {
43261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43262       };
43263     }
43264   }
43265   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
43266   return jresult;
43267 }
43268
43269
43270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
43271   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43272
43273   arg1 = (Dali::FrameBufferImage *)jarg1;
43274   {
43275     try {
43276       delete arg1;
43277     } catch (std::out_of_range& e) {
43278       {
43279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43280       };
43281     } catch (std::exception& e) {
43282       {
43283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43284       };
43285     } catch (...) {
43286       {
43287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43288       };
43289     }
43290   }
43291 }
43292
43293
43294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
43295   void * jresult ;
43296   Dali::FrameBufferImage *arg1 = 0 ;
43297   Dali::FrameBufferImage *result = 0 ;
43298
43299   arg1 = (Dali::FrameBufferImage *)jarg1;
43300   if (!arg1) {
43301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43302     return 0;
43303   }
43304   {
43305     try {
43306       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
43307     } catch (std::out_of_range& e) {
43308       {
43309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43310       };
43311     } catch (std::exception& e) {
43312       {
43313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43314       };
43315     } catch (...) {
43316       {
43317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43318       };
43319     }
43320   }
43321   jresult = (void *)result;
43322   return jresult;
43323 }
43324
43325
43326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
43327   void * jresult ;
43328   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
43329   Dali::FrameBufferImage *arg2 = 0 ;
43330   Dali::FrameBufferImage *result = 0 ;
43331
43332   arg1 = (Dali::FrameBufferImage *)jarg1;
43333   arg2 = (Dali::FrameBufferImage *)jarg2;
43334   if (!arg2) {
43335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
43336     return 0;
43337   }
43338   {
43339     try {
43340       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
43341     } catch (std::out_of_range& e) {
43342       {
43343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43344       };
43345     } catch (std::exception& e) {
43346       {
43347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43348       };
43349     } catch (...) {
43350       {
43351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43352       };
43353     }
43354   }
43355   jresult = (void *)result;
43356   return jresult;
43357 }
43358
43359
43360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
43361   void * jresult ;
43362   Dali::NinePatchImage *result = 0 ;
43363
43364   {
43365     try {
43366       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
43367     } catch (std::out_of_range& e) {
43368       {
43369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43370       };
43371     } catch (std::exception& e) {
43372       {
43373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43374       };
43375     } catch (...) {
43376       {
43377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43378       };
43379     }
43380   }
43381   jresult = (void *)result;
43382   return jresult;
43383 }
43384
43385
43386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
43387   void * jresult ;
43388   std::string *arg1 = 0 ;
43389   Dali::NinePatchImage result;
43390
43391   if (!jarg1) {
43392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43393     return 0;
43394   }
43395   std::string arg1_str(jarg1);
43396   arg1 = &arg1_str;
43397   {
43398     try {
43399       result = Dali::NinePatchImage::New((std::string const &)*arg1);
43400     } catch (std::out_of_range& e) {
43401       {
43402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43403       };
43404     } catch (std::exception& e) {
43405       {
43406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43407       };
43408     } catch (...) {
43409       {
43410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43411       };
43412     }
43413   }
43414   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43415
43416   //argout typemap for const std::string&
43417
43418   return jresult;
43419 }
43420
43421
43422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
43423   void * jresult ;
43424   Dali::BaseHandle arg1 ;
43425   Dali::BaseHandle *argp1 ;
43426   Dali::NinePatchImage result;
43427
43428   argp1 = (Dali::BaseHandle *)jarg1;
43429   if (!argp1) {
43430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43431     return 0;
43432   }
43433   arg1 = *argp1;
43434   {
43435     try {
43436       result = Dali::NinePatchImage::DownCast(arg1);
43437     } catch (std::out_of_range& e) {
43438       {
43439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43440       };
43441     } catch (std::exception& e) {
43442       {
43443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43444       };
43445     } catch (...) {
43446       {
43447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43448       };
43449     }
43450   }
43451   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
43452   return jresult;
43453 }
43454
43455
43456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
43457   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43458
43459   arg1 = (Dali::NinePatchImage *)jarg1;
43460   {
43461     try {
43462       delete arg1;
43463     } catch (std::out_of_range& e) {
43464       {
43465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43466       };
43467     } catch (std::exception& e) {
43468       {
43469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43470       };
43471     } catch (...) {
43472       {
43473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43474       };
43475     }
43476   }
43477 }
43478
43479
43480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
43481   void * jresult ;
43482   Dali::NinePatchImage *arg1 = 0 ;
43483   Dali::NinePatchImage *result = 0 ;
43484
43485   arg1 = (Dali::NinePatchImage *)jarg1;
43486   if (!arg1) {
43487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43488     return 0;
43489   }
43490   {
43491     try {
43492       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
43493     } catch (std::out_of_range& e) {
43494       {
43495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43496       };
43497     } catch (std::exception& e) {
43498       {
43499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43500       };
43501     } catch (...) {
43502       {
43503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43504       };
43505     }
43506   }
43507   jresult = (void *)result;
43508   return jresult;
43509 }
43510
43511
43512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
43513   void * jresult ;
43514   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43515   Dali::NinePatchImage *arg2 = 0 ;
43516   Dali::NinePatchImage *result = 0 ;
43517
43518   arg1 = (Dali::NinePatchImage *)jarg1;
43519   arg2 = (Dali::NinePatchImage *)jarg2;
43520   if (!arg2) {
43521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
43522     return 0;
43523   }
43524   {
43525     try {
43526       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
43527     } catch (std::out_of_range& e) {
43528       {
43529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43530       };
43531     } catch (std::exception& e) {
43532       {
43533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43534       };
43535     } catch (...) {
43536       {
43537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43538       };
43539     }
43540   }
43541   jresult = (void *)result;
43542   return jresult;
43543 }
43544
43545
43546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
43547   void * jresult ;
43548   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43549   Dali::Vector4 result;
43550
43551   arg1 = (Dali::NinePatchImage *)jarg1;
43552   {
43553     try {
43554       result = (arg1)->GetStretchBorders();
43555     } catch (std::out_of_range& e) {
43556       {
43557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43558       };
43559     } catch (std::exception& e) {
43560       {
43561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43562       };
43563     } catch (...) {
43564       {
43565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43566       };
43567     }
43568   }
43569   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43570   return jresult;
43571 }
43572
43573
43574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
43575   void * jresult ;
43576   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43577   Dali::NinePatchImage::StretchRanges *result = 0 ;
43578
43579   arg1 = (Dali::NinePatchImage *)jarg1;
43580   {
43581     try {
43582       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
43583     } catch (std::out_of_range& e) {
43584       {
43585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43586       };
43587     } catch (std::exception& e) {
43588       {
43589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43590       };
43591     } catch (...) {
43592       {
43593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43594       };
43595     }
43596   }
43597   jresult = (void *)result;
43598   return jresult;
43599 }
43600
43601
43602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
43603   void * jresult ;
43604   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43605   Dali::NinePatchImage::StretchRanges *result = 0 ;
43606
43607   arg1 = (Dali::NinePatchImage *)jarg1;
43608   {
43609     try {
43610       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
43611     } catch (std::out_of_range& e) {
43612       {
43613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43614       };
43615     } catch (std::exception& e) {
43616       {
43617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43618       };
43619     } catch (...) {
43620       {
43621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43622       };
43623     }
43624   }
43625   jresult = (void *)result;
43626   return jresult;
43627 }
43628
43629
43630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
43631   void * jresult ;
43632   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43633   Dali::Rect< int > result;
43634
43635   arg1 = (Dali::NinePatchImage *)jarg1;
43636   {
43637     try {
43638       result = (arg1)->GetChildRectangle();
43639     } catch (std::out_of_range& e) {
43640       {
43641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43642       };
43643     } catch (std::exception& e) {
43644       {
43645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43646       };
43647     } catch (...) {
43648       {
43649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43650       };
43651     }
43652   }
43653   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
43654   return jresult;
43655 }
43656
43657
43658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
43659   void * jresult ;
43660   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
43661   Dali::BufferImage result;
43662
43663   arg1 = (Dali::NinePatchImage *)jarg1;
43664   {
43665     try {
43666       result = (arg1)->CreateCroppedBufferImage();
43667     } catch (std::out_of_range& e) {
43668       {
43669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43670       };
43671     } catch (std::exception& e) {
43672       {
43673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43674       };
43675     } catch (...) {
43676       {
43677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43678       };
43679     }
43680   }
43681   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
43682   return jresult;
43683 }
43684
43685
43686 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
43687   unsigned int jresult ;
43688   std::string *arg1 = 0 ;
43689   bool result;
43690
43691   if (!jarg1) {
43692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
43693     return 0;
43694   }
43695   std::string arg1_str(jarg1);
43696   arg1 = &arg1_str;
43697   {
43698     try {
43699       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
43700     } catch (std::out_of_range& e) {
43701       {
43702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43703       };
43704     } catch (std::exception& e) {
43705       {
43706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43707       };
43708     } catch (...) {
43709       {
43710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43711       };
43712     }
43713   }
43714   jresult = result;
43715
43716   //argout typemap for const std::string&
43717
43718   return jresult;
43719 }
43720
43721
43722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
43723   int jresult ;
43724   int result;
43725
43726   result = (int)Dali::CameraActor::Property::TYPE;
43727   jresult = (int)result;
43728   return jresult;
43729 }
43730
43731
43732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
43733   int jresult ;
43734   int result;
43735
43736   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
43737   jresult = (int)result;
43738   return jresult;
43739 }
43740
43741
43742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
43743   int jresult ;
43744   int result;
43745
43746   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
43747   jresult = (int)result;
43748   return jresult;
43749 }
43750
43751
43752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
43753   int jresult ;
43754   int result;
43755
43756   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
43757   jresult = (int)result;
43758   return jresult;
43759 }
43760
43761
43762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
43763   int jresult ;
43764   int result;
43765
43766   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
43767   jresult = (int)result;
43768   return jresult;
43769 }
43770
43771
43772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
43773   int jresult ;
43774   int result;
43775
43776   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
43777   jresult = (int)result;
43778   return jresult;
43779 }
43780
43781
43782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
43783   int jresult ;
43784   int result;
43785
43786   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
43787   jresult = (int)result;
43788   return jresult;
43789 }
43790
43791
43792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
43793   int jresult ;
43794   int result;
43795
43796   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
43797   jresult = (int)result;
43798   return jresult;
43799 }
43800
43801
43802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
43803   int jresult ;
43804   int result;
43805
43806   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
43807   jresult = (int)result;
43808   return jresult;
43809 }
43810
43811
43812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
43813   int jresult ;
43814   int result;
43815
43816   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
43817   jresult = (int)result;
43818   return jresult;
43819 }
43820
43821
43822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
43823   int jresult ;
43824   int result;
43825
43826   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
43827   jresult = (int)result;
43828   return jresult;
43829 }
43830
43831
43832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
43833   int jresult ;
43834   int result;
43835
43836   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
43837   jresult = (int)result;
43838   return jresult;
43839 }
43840
43841
43842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
43843   int jresult ;
43844   int result;
43845
43846   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
43847   jresult = (int)result;
43848   return jresult;
43849 }
43850
43851
43852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
43853   int jresult ;
43854   int result;
43855
43856   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
43857   jresult = (int)result;
43858   return jresult;
43859 }
43860
43861
43862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
43863   void * jresult ;
43864   Dali::CameraActor::Property *result = 0 ;
43865
43866   {
43867     try {
43868       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
43869     } catch (std::out_of_range& e) {
43870       {
43871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43872       };
43873     } catch (std::exception& e) {
43874       {
43875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43876       };
43877     } catch (...) {
43878       {
43879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43880       };
43881     }
43882   }
43883   jresult = (void *)result;
43884   return jresult;
43885 }
43886
43887
43888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
43889   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
43890
43891   arg1 = (Dali::CameraActor::Property *)jarg1;
43892   {
43893     try {
43894       delete arg1;
43895     } catch (std::out_of_range& e) {
43896       {
43897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43898       };
43899     } catch (std::exception& e) {
43900       {
43901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43902       };
43903     } catch (...) {
43904       {
43905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43906       };
43907     }
43908   }
43909 }
43910
43911
43912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
43913   void * jresult ;
43914   Dali::CameraActor *result = 0 ;
43915
43916   {
43917     try {
43918       result = (Dali::CameraActor *)new Dali::CameraActor();
43919     } catch (std::out_of_range& e) {
43920       {
43921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43922       };
43923     } catch (std::exception& e) {
43924       {
43925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43926       };
43927     } catch (...) {
43928       {
43929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43930       };
43931     }
43932   }
43933   jresult = (void *)result;
43934   return jresult;
43935 }
43936
43937
43938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
43939   void * jresult ;
43940   Dali::CameraActor result;
43941
43942   {
43943     try {
43944       result = Dali::CameraActor::New();
43945     } catch (std::out_of_range& e) {
43946       {
43947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43948       };
43949     } catch (std::exception& e) {
43950       {
43951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43952       };
43953     } catch (...) {
43954       {
43955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43956       };
43957     }
43958   }
43959   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43960   return jresult;
43961 }
43962
43963
43964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
43965   void * jresult ;
43966   Dali::Size *arg1 = 0 ;
43967   Dali::CameraActor result;
43968
43969   arg1 = (Dali::Size *)jarg1;
43970   if (!arg1) {
43971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
43972     return 0;
43973   }
43974   {
43975     try {
43976       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
43977     } catch (std::out_of_range& e) {
43978       {
43979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43980       };
43981     } catch (std::exception& e) {
43982       {
43983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43984       };
43985     } catch (...) {
43986       {
43987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43988       };
43989     }
43990   }
43991   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
43992   return jresult;
43993 }
43994
43995
43996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
43997   void * jresult ;
43998   Dali::BaseHandle arg1 ;
43999   Dali::BaseHandle *argp1 ;
44000   Dali::CameraActor result;
44001
44002   argp1 = (Dali::BaseHandle *)jarg1;
44003   if (!argp1) {
44004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44005     return 0;
44006   }
44007   arg1 = *argp1;
44008   {
44009     try {
44010       result = Dali::CameraActor::DownCast(arg1);
44011     } catch (std::out_of_range& e) {
44012       {
44013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44014       };
44015     } catch (std::exception& e) {
44016       {
44017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44018       };
44019     } catch (...) {
44020       {
44021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44022       };
44023     }
44024   }
44025   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44026   return jresult;
44027 }
44028
44029
44030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44031   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44032
44033   arg1 = (Dali::CameraActor *)jarg1;
44034   {
44035     try {
44036       delete arg1;
44037     } catch (std::out_of_range& e) {
44038       {
44039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44040       };
44041     } catch (std::exception& e) {
44042       {
44043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44044       };
44045     } catch (...) {
44046       {
44047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44048       };
44049     }
44050   }
44051 }
44052
44053
44054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44055   void * jresult ;
44056   Dali::CameraActor *arg1 = 0 ;
44057   Dali::CameraActor *result = 0 ;
44058
44059   arg1 = (Dali::CameraActor *)jarg1;
44060   if (!arg1) {
44061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44062     return 0;
44063   }
44064   {
44065     try {
44066       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44067     } catch (std::out_of_range& e) {
44068       {
44069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44070       };
44071     } catch (std::exception& e) {
44072       {
44073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44074       };
44075     } catch (...) {
44076       {
44077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44078       };
44079     }
44080   }
44081   jresult = (void *)result;
44082   return jresult;
44083 }
44084
44085
44086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44087   void * jresult ;
44088   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44089   Dali::CameraActor *arg2 = 0 ;
44090   Dali::CameraActor *result = 0 ;
44091
44092   arg1 = (Dali::CameraActor *)jarg1;
44093   arg2 = (Dali::CameraActor *)jarg2;
44094   if (!arg2) {
44095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44096     return 0;
44097   }
44098   {
44099     try {
44100       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44101     } catch (std::out_of_range& e) {
44102       {
44103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44104       };
44105     } catch (std::exception& e) {
44106       {
44107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44108       };
44109     } catch (...) {
44110       {
44111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44112       };
44113     }
44114   }
44115   jresult = (void *)result;
44116   return jresult;
44117 }
44118
44119
44120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44121   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44122   Dali::Camera::Type arg2 ;
44123
44124   arg1 = (Dali::CameraActor *)jarg1;
44125   arg2 = (Dali::Camera::Type)jarg2;
44126   {
44127     try {
44128       (arg1)->SetType(arg2);
44129     } catch (std::out_of_range& e) {
44130       {
44131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44132       };
44133     } catch (std::exception& e) {
44134       {
44135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44136       };
44137     } catch (...) {
44138       {
44139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44140       };
44141     }
44142   }
44143 }
44144
44145
44146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44147   int jresult ;
44148   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44149   Dali::Camera::Type result;
44150
44151   arg1 = (Dali::CameraActor *)jarg1;
44152   {
44153     try {
44154       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44155     } catch (std::out_of_range& e) {
44156       {
44157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44158       };
44159     } catch (std::exception& e) {
44160       {
44161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44162       };
44163     } catch (...) {
44164       {
44165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44166       };
44167     }
44168   }
44169   jresult = (int)result;
44170   return jresult;
44171 }
44172
44173
44174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44175   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44176   Dali::Camera::ProjectionMode arg2 ;
44177
44178   arg1 = (Dali::CameraActor *)jarg1;
44179   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44180   {
44181     try {
44182       (arg1)->SetProjectionMode(arg2);
44183     } catch (std::out_of_range& e) {
44184       {
44185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44186       };
44187     } catch (std::exception& e) {
44188       {
44189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44190       };
44191     } catch (...) {
44192       {
44193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44194       };
44195     }
44196   }
44197 }
44198
44199
44200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44201   int jresult ;
44202   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44203   Dali::Camera::ProjectionMode result;
44204
44205   arg1 = (Dali::CameraActor *)jarg1;
44206   {
44207     try {
44208       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44209     } catch (std::out_of_range& e) {
44210       {
44211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44212       };
44213     } catch (std::exception& e) {
44214       {
44215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44216       };
44217     } catch (...) {
44218       {
44219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44220       };
44221     }
44222   }
44223   jresult = (int)result;
44224   return jresult;
44225 }
44226
44227
44228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
44229   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44230   float arg2 ;
44231
44232   arg1 = (Dali::CameraActor *)jarg1;
44233   arg2 = (float)jarg2;
44234   {
44235     try {
44236       (arg1)->SetFieldOfView(arg2);
44237     } catch (std::out_of_range& e) {
44238       {
44239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44240       };
44241     } catch (std::exception& e) {
44242       {
44243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44244       };
44245     } catch (...) {
44246       {
44247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44248       };
44249     }
44250   }
44251 }
44252
44253
44254 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
44255   float jresult ;
44256   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44257   float result;
44258
44259   arg1 = (Dali::CameraActor *)jarg1;
44260   {
44261     try {
44262       result = (float)(arg1)->GetFieldOfView();
44263     } catch (std::out_of_range& e) {
44264       {
44265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44266       };
44267     } catch (std::exception& e) {
44268       {
44269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44270       };
44271     } catch (...) {
44272       {
44273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44274       };
44275     }
44276   }
44277   jresult = result;
44278   return jresult;
44279 }
44280
44281
44282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
44283   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44284   float arg2 ;
44285
44286   arg1 = (Dali::CameraActor *)jarg1;
44287   arg2 = (float)jarg2;
44288   {
44289     try {
44290       (arg1)->SetAspectRatio(arg2);
44291     } catch (std::out_of_range& e) {
44292       {
44293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44294       };
44295     } catch (std::exception& e) {
44296       {
44297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44298       };
44299     } catch (...) {
44300       {
44301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44302       };
44303     }
44304   }
44305 }
44306
44307
44308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
44309   float jresult ;
44310   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44311   float result;
44312
44313   arg1 = (Dali::CameraActor *)jarg1;
44314   {
44315     try {
44316       result = (float)(arg1)->GetAspectRatio();
44317     } catch (std::out_of_range& e) {
44318       {
44319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44320       };
44321     } catch (std::exception& e) {
44322       {
44323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44324       };
44325     } catch (...) {
44326       {
44327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44328       };
44329     }
44330   }
44331   jresult = result;
44332   return jresult;
44333 }
44334
44335
44336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
44337   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44338   float arg2 ;
44339
44340   arg1 = (Dali::CameraActor *)jarg1;
44341   arg2 = (float)jarg2;
44342   {
44343     try {
44344       (arg1)->SetNearClippingPlane(arg2);
44345     } catch (std::out_of_range& e) {
44346       {
44347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44348       };
44349     } catch (std::exception& e) {
44350       {
44351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44352       };
44353     } catch (...) {
44354       {
44355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44356       };
44357     }
44358   }
44359 }
44360
44361
44362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
44363   float jresult ;
44364   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44365   float result;
44366
44367   arg1 = (Dali::CameraActor *)jarg1;
44368   {
44369     try {
44370       result = (float)(arg1)->GetNearClippingPlane();
44371     } catch (std::out_of_range& e) {
44372       {
44373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44374       };
44375     } catch (std::exception& e) {
44376       {
44377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44378       };
44379     } catch (...) {
44380       {
44381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44382       };
44383     }
44384   }
44385   jresult = result;
44386   return jresult;
44387 }
44388
44389
44390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
44391   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44392   float arg2 ;
44393
44394   arg1 = (Dali::CameraActor *)jarg1;
44395   arg2 = (float)jarg2;
44396   {
44397     try {
44398       (arg1)->SetFarClippingPlane(arg2);
44399     } catch (std::out_of_range& e) {
44400       {
44401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44402       };
44403     } catch (std::exception& e) {
44404       {
44405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44406       };
44407     } catch (...) {
44408       {
44409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44410       };
44411     }
44412   }
44413 }
44414
44415
44416 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
44417   float jresult ;
44418   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44419   float result;
44420
44421   arg1 = (Dali::CameraActor *)jarg1;
44422   {
44423     try {
44424       result = (float)(arg1)->GetFarClippingPlane();
44425     } catch (std::out_of_range& e) {
44426       {
44427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44428       };
44429     } catch (std::exception& e) {
44430       {
44431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44432       };
44433     } catch (...) {
44434       {
44435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44436       };
44437     }
44438   }
44439   jresult = result;
44440   return jresult;
44441 }
44442
44443
44444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
44445   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44446   Dali::Vector3 *arg2 = 0 ;
44447
44448   arg1 = (Dali::CameraActor *)jarg1;
44449   arg2 = (Dali::Vector3 *)jarg2;
44450   if (!arg2) {
44451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
44452     return ;
44453   }
44454   {
44455     try {
44456       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
44457     } catch (std::out_of_range& e) {
44458       {
44459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44460       };
44461     } catch (std::exception& e) {
44462       {
44463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44464       };
44465     } catch (...) {
44466       {
44467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44468       };
44469     }
44470   }
44471 }
44472
44473
44474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
44475   void * jresult ;
44476   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44477   Dali::Vector3 result;
44478
44479   arg1 = (Dali::CameraActor *)jarg1;
44480   {
44481     try {
44482       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
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 = new Dali::Vector3((const Dali::Vector3 &)result);
44498   return jresult;
44499 }
44500
44501
44502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
44503   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44504   bool arg2 ;
44505
44506   arg1 = (Dali::CameraActor *)jarg1;
44507   arg2 = jarg2 ? true : false;
44508   {
44509     try {
44510       (arg1)->SetInvertYAxis(arg2);
44511     } catch (std::out_of_range& e) {
44512       {
44513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44514       };
44515     } catch (std::exception& e) {
44516       {
44517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44518       };
44519     } catch (...) {
44520       {
44521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44522       };
44523     }
44524   }
44525 }
44526
44527
44528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
44529   unsigned int jresult ;
44530   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44531   bool result;
44532
44533   arg1 = (Dali::CameraActor *)jarg1;
44534   {
44535     try {
44536       result = (bool)(arg1)->GetInvertYAxis();
44537     } catch (std::out_of_range& e) {
44538       {
44539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44540       };
44541     } catch (std::exception& e) {
44542       {
44543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44544       };
44545     } catch (...) {
44546       {
44547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44548       };
44549     }
44550   }
44551   jresult = result;
44552   return jresult;
44553 }
44554
44555
44556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
44557   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44558   Dali::Size *arg2 = 0 ;
44559
44560   arg1 = (Dali::CameraActor *)jarg1;
44561   arg2 = (Dali::Size *)jarg2;
44562   if (!arg2) {
44563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44564     return ;
44565   }
44566   {
44567     try {
44568       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
44569     } catch (std::out_of_range& e) {
44570       {
44571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44572       };
44573     } catch (std::exception& e) {
44574       {
44575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44576       };
44577     } catch (...) {
44578       {
44579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44580       };
44581     }
44582   }
44583 }
44584
44585
44586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
44587   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44588   Dali::Size *arg2 = 0 ;
44589
44590   arg1 = (Dali::CameraActor *)jarg1;
44591   arg2 = (Dali::Size *)jarg2;
44592   if (!arg2) {
44593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44594     return ;
44595   }
44596   {
44597     try {
44598       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
44599     } catch (std::out_of_range& e) {
44600       {
44601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44602       };
44603     } catch (std::exception& e) {
44604       {
44605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44606       };
44607     } catch (...) {
44608       {
44609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44610       };
44611     }
44612   }
44613 }
44614
44615
44616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
44617   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44618   float arg2 ;
44619   float arg3 ;
44620   float arg4 ;
44621   float arg5 ;
44622   float arg6 ;
44623   float arg7 ;
44624
44625   arg1 = (Dali::CameraActor *)jarg1;
44626   arg2 = (float)jarg2;
44627   arg3 = (float)jarg3;
44628   arg4 = (float)jarg4;
44629   arg5 = (float)jarg5;
44630   arg6 = (float)jarg6;
44631   arg7 = (float)jarg7;
44632   {
44633     try {
44634       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
44635     } catch (std::out_of_range& e) {
44636       {
44637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44638       };
44639     } catch (std::exception& e) {
44640       {
44641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44642       };
44643     } catch (...) {
44644       {
44645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44646       };
44647     }
44648   }
44649 }
44650
44651
44652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
44653   void * jresult ;
44654   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44655
44656   {
44657     try {
44658       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
44659     } catch (std::out_of_range& e) {
44660       {
44661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44662       };
44663     } catch (std::exception& e) {
44664       {
44665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44666       };
44667     } catch (...) {
44668       {
44669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44670       };
44671     }
44672   }
44673   jresult = (void *)result;
44674   return jresult;
44675 }
44676
44677
44678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
44679   void * jresult ;
44680   std::string arg1 ;
44681   Dali::Property::Value arg2 ;
44682   Dali::Property::Value *argp2 ;
44683   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44684
44685   if (!jarg1) {
44686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44687     return 0;
44688   }
44689   (&arg1)->assign(jarg1);
44690   argp2 = (Dali::Property::Value *)jarg2;
44691   if (!argp2) {
44692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
44693     return 0;
44694   }
44695   arg2 = *argp2;
44696   {
44697     try {
44698       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
44699     } catch (std::out_of_range& e) {
44700       {
44701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44702       };
44703     } catch (std::exception& e) {
44704       {
44705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44706       };
44707     } catch (...) {
44708       {
44709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44710       };
44711     }
44712   }
44713   jresult = (void *)result;
44714   return jresult;
44715 }
44716
44717
44718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
44719   void * jresult ;
44720   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
44721   std::pair< std::string,Dali::Property::Value > *result = 0 ;
44722
44723   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44724   if (!arg1) {
44725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
44726     return 0;
44727   }
44728   {
44729     try {
44730       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);
44731     } catch (std::out_of_range& e) {
44732       {
44733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44734       };
44735     } catch (std::exception& e) {
44736       {
44737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44738       };
44739     } catch (...) {
44740       {
44741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44742       };
44743     }
44744   }
44745   jresult = (void *)result;
44746   return jresult;
44747 }
44748
44749
44750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
44751   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44752   std::string *arg2 = 0 ;
44753
44754   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44755   if (!jarg2) {
44756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
44757     return ;
44758   }
44759   std::string arg2_str(jarg2);
44760   arg2 = &arg2_str;
44761   if (arg1) (arg1)->first = *arg2;
44762
44763   //argout typemap for const std::string&
44764
44765 }
44766
44767
44768 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
44769   char * jresult ;
44770   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44771   std::string *result = 0 ;
44772
44773   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44774   result = (std::string *) & ((arg1)->first);
44775   jresult = SWIG_csharp_string_callback(result->c_str());
44776   return jresult;
44777 }
44778
44779
44780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
44781   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44782   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
44783
44784   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44785   arg2 = (Dali::Property::Value *)jarg2;
44786   if (arg1) (arg1)->second = *arg2;
44787 }
44788
44789
44790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
44791   void * jresult ;
44792   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44793   Dali::Property::Value *result = 0 ;
44794
44795   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44796   result = (Dali::Property::Value *)& ((arg1)->second);
44797   jresult = (void *)result;
44798   return jresult;
44799 }
44800
44801
44802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
44803   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
44804
44805   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
44806   {
44807     try {
44808       delete arg1;
44809     } catch (std::out_of_range& e) {
44810       {
44811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44812       };
44813     } catch (std::exception& e) {
44814       {
44815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44816       };
44817     } catch (...) {
44818       {
44819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44820       };
44821     }
44822   }
44823 }
44824
44825
44826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
44827   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44828
44829   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44830   {
44831     try {
44832       (arg1)->clear();
44833     } catch (std::out_of_range& e) {
44834       {
44835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44836       };
44837     } catch (std::exception& e) {
44838       {
44839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44840       };
44841     } catch (...) {
44842       {
44843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44844       };
44845     }
44846   }
44847 }
44848
44849
44850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
44851   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44852   Dali::TouchPoint *arg2 = 0 ;
44853
44854   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44855   arg2 = (Dali::TouchPoint *)jarg2;
44856   if (!arg2) {
44857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
44858     return ;
44859   }
44860   {
44861     try {
44862       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
44863     } catch (std::out_of_range& e) {
44864       {
44865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44866       };
44867     } catch (std::exception& e) {
44868       {
44869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44870       };
44871     } catch (...) {
44872       {
44873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44874       };
44875     }
44876   }
44877 }
44878
44879
44880 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
44881   unsigned long jresult ;
44882   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44883   std::vector< Dali::TouchPoint >::size_type result;
44884
44885   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44886   {
44887     try {
44888       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
44889     } catch (std::out_of_range& e) {
44890       {
44891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44892       };
44893     } catch (std::exception& e) {
44894       {
44895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44896       };
44897     } catch (...) {
44898       {
44899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44900       };
44901     }
44902   }
44903   jresult = (unsigned long)result;
44904   return jresult;
44905 }
44906
44907
44908 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
44909   unsigned long jresult ;
44910   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44911   std::vector< Dali::TouchPoint >::size_type result;
44912
44913   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44914   {
44915     try {
44916       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
44917     } catch (std::out_of_range& e) {
44918       {
44919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44920       };
44921     } catch (std::exception& e) {
44922       {
44923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44924       };
44925     } catch (...) {
44926       {
44927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44928       };
44929     }
44930   }
44931   jresult = (unsigned long)result;
44932   return jresult;
44933 }
44934
44935
44936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
44937   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
44938   std::vector< Dali::TouchPoint >::size_type arg2 ;
44939
44940   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44941   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
44942   {
44943     try {
44944       (arg1)->reserve(arg2);
44945     } catch (std::out_of_range& e) {
44946       {
44947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44948       };
44949     } catch (std::exception& e) {
44950       {
44951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44952       };
44953     } catch (...) {
44954       {
44955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44956       };
44957     }
44958   }
44959 }
44960
44961
44962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
44963   void * jresult ;
44964   std::vector< Dali::TouchPoint > *result = 0 ;
44965
44966   {
44967     try {
44968       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
44969     } catch (std::out_of_range& e) {
44970       {
44971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44972       };
44973     } catch (std::exception& e) {
44974       {
44975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44976       };
44977     } catch (...) {
44978       {
44979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44980       };
44981     }
44982   }
44983   jresult = (void *)result;
44984   return jresult;
44985 }
44986
44987
44988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
44989   void * jresult ;
44990   std::vector< Dali::TouchPoint > *arg1 = 0 ;
44991   std::vector< Dali::TouchPoint > *result = 0 ;
44992
44993   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
44994   if (!arg1) {
44995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
44996     return 0;
44997   }
44998   {
44999     try {
45000       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45001     } catch (std::out_of_range& e) {
45002       {
45003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45004       };
45005     } catch (std::exception& e) {
45006       {
45007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45008       };
45009     } catch (...) {
45010       {
45011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45012       };
45013     }
45014   }
45015   jresult = (void *)result;
45016   return jresult;
45017 }
45018
45019
45020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45021   void * jresult ;
45022   int arg1 ;
45023   std::vector< Dali::TouchPoint > *result = 0 ;
45024
45025   arg1 = (int)jarg1;
45026   {
45027     try {
45028       try {
45029         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45030       }
45031       catch(std::out_of_range &_e) {
45032         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45033         return 0;
45034       }
45035
45036     } catch (std::out_of_range& e) {
45037       {
45038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45039       };
45040     } catch (std::exception& e) {
45041       {
45042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45043       };
45044     } catch (...) {
45045       {
45046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45047       };
45048     }
45049   }
45050   jresult = (void *)result;
45051   return jresult;
45052 }
45053
45054
45055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45056   void * jresult ;
45057   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45058   int arg2 ;
45059   SwigValueWrapper< Dali::TouchPoint > result;
45060
45061   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45062   arg2 = (int)jarg2;
45063   {
45064     try {
45065       try {
45066         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45067       }
45068       catch(std::out_of_range &_e) {
45069         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45070         return 0;
45071       }
45072
45073     } catch (std::out_of_range& e) {
45074       {
45075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45076       };
45077     } catch (std::exception& e) {
45078       {
45079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45080       };
45081     } catch (...) {
45082       {
45083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45084       };
45085     }
45086   }
45087   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
45088   return jresult;
45089 }
45090
45091
45092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
45093   void * jresult ;
45094   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45095   int arg2 ;
45096   Dali::TouchPoint *result = 0 ;
45097
45098   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45099   arg2 = (int)jarg2;
45100   {
45101     try {
45102       try {
45103         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
45104       }
45105       catch(std::out_of_range &_e) {
45106         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45107         return 0;
45108       }
45109
45110     } catch (std::out_of_range& e) {
45111       {
45112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45113       };
45114     } catch (std::exception& e) {
45115       {
45116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45117       };
45118     } catch (...) {
45119       {
45120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45121       };
45122     }
45123   }
45124   jresult = (void *)result;
45125   return jresult;
45126 }
45127
45128
45129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
45130   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45131   int arg2 ;
45132   Dali::TouchPoint *arg3 = 0 ;
45133
45134   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45135   arg2 = (int)jarg2;
45136   arg3 = (Dali::TouchPoint *)jarg3;
45137   if (!arg3) {
45138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45139     return ;
45140   }
45141   {
45142     try {
45143       try {
45144         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45145       }
45146       catch(std::out_of_range &_e) {
45147         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45148         return ;
45149       }
45150
45151     } catch (std::out_of_range& e) {
45152       {
45153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45154       };
45155     } catch (std::exception& e) {
45156       {
45157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45158       };
45159     } catch (...) {
45160       {
45161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45162       };
45163     }
45164   }
45165 }
45166
45167
45168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
45169   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45170   std::vector< Dali::TouchPoint > *arg2 = 0 ;
45171
45172   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45173   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
45174   if (!arg2) {
45175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45176     return ;
45177   }
45178   {
45179     try {
45180       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
45181     } catch (std::out_of_range& e) {
45182       {
45183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45184       };
45185     } catch (std::exception& e) {
45186       {
45187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45188       };
45189     } catch (...) {
45190       {
45191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45192       };
45193     }
45194   }
45195 }
45196
45197
45198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
45199   void * jresult ;
45200   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45201   int arg2 ;
45202   int arg3 ;
45203   std::vector< Dali::TouchPoint > *result = 0 ;
45204
45205   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45206   arg2 = (int)jarg2;
45207   arg3 = (int)jarg3;
45208   {
45209     try {
45210       try {
45211         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
45212       }
45213       catch(std::out_of_range &_e) {
45214         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45215         return 0;
45216       }
45217       catch(std::invalid_argument &_e) {
45218         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45219         return 0;
45220       }
45221
45222     } catch (std::out_of_range& e) {
45223       {
45224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45225       };
45226     } catch (std::exception& e) {
45227       {
45228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45229       };
45230     } catch (...) {
45231       {
45232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45233       };
45234     }
45235   }
45236   jresult = (void *)result;
45237   return jresult;
45238 }
45239
45240
45241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
45242   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45243   int arg2 ;
45244   Dali::TouchPoint *arg3 = 0 ;
45245
45246   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45247   arg2 = (int)jarg2;
45248   arg3 = (Dali::TouchPoint *)jarg3;
45249   if (!arg3) {
45250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45251     return ;
45252   }
45253   {
45254     try {
45255       try {
45256         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
45257       }
45258       catch(std::out_of_range &_e) {
45259         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45260         return ;
45261       }
45262
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_InsertRange(void * jarg1, int jarg2, void * jarg3) {
45281   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45282   int arg2 ;
45283   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45284
45285   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45286   arg2 = (int)jarg2;
45287   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45288   if (!arg3) {
45289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45290     return ;
45291   }
45292   {
45293     try {
45294       try {
45295         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45296       }
45297       catch(std::out_of_range &_e) {
45298         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_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_RemoveAt(void * jarg1, int jarg2) {
45320   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45321   int arg2 ;
45322
45323   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45324   arg2 = (int)jarg2;
45325   {
45326     try {
45327       try {
45328         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
45329       }
45330       catch(std::out_of_range &_e) {
45331         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45332         return ;
45333       }
45334
45335     } catch (std::out_of_range& e) {
45336       {
45337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45338       };
45339     } catch (std::exception& e) {
45340       {
45341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45342       };
45343     } catch (...) {
45344       {
45345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45346       };
45347     }
45348   }
45349 }
45350
45351
45352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
45353   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45354   int arg2 ;
45355   int arg3 ;
45356
45357   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45358   arg2 = (int)jarg2;
45359   arg3 = (int)jarg3;
45360   {
45361     try {
45362       try {
45363         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
45364       }
45365       catch(std::out_of_range &_e) {
45366         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45367         return ;
45368       }
45369       catch(std::invalid_argument &_e) {
45370         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45371         return ;
45372       }
45373
45374     } catch (std::out_of_range& e) {
45375       {
45376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45377       };
45378     } catch (std::exception& e) {
45379       {
45380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45381       };
45382     } catch (...) {
45383       {
45384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45385       };
45386     }
45387   }
45388 }
45389
45390
45391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
45392   void * jresult ;
45393   Dali::TouchPoint *arg1 = 0 ;
45394   int arg2 ;
45395   std::vector< Dali::TouchPoint > *result = 0 ;
45396
45397   arg1 = (Dali::TouchPoint *)jarg1;
45398   if (!arg1) {
45399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45400     return 0;
45401   }
45402   arg2 = (int)jarg2;
45403   {
45404     try {
45405       try {
45406         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
45407       }
45408       catch(std::out_of_range &_e) {
45409         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45410         return 0;
45411       }
45412
45413     } catch (std::out_of_range& e) {
45414       {
45415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45416       };
45417     } catch (std::exception& e) {
45418       {
45419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45420       };
45421     } catch (...) {
45422       {
45423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45424       };
45425     }
45426   }
45427   jresult = (void *)result;
45428   return jresult;
45429 }
45430
45431
45432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
45433   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45434
45435   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45436   {
45437     try {
45438       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
45439     } catch (std::out_of_range& e) {
45440       {
45441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45442       };
45443     } catch (std::exception& e) {
45444       {
45445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45446       };
45447     } catch (...) {
45448       {
45449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45450       };
45451     }
45452   }
45453 }
45454
45455
45456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
45457   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45458   int arg2 ;
45459   int arg3 ;
45460
45461   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45462   arg2 = (int)jarg2;
45463   arg3 = (int)jarg3;
45464   {
45465     try {
45466       try {
45467         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
45468       }
45469       catch(std::out_of_range &_e) {
45470         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45471         return ;
45472       }
45473       catch(std::invalid_argument &_e) {
45474         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
45475         return ;
45476       }
45477
45478     } catch (std::out_of_range& e) {
45479       {
45480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45481       };
45482     } catch (std::exception& e) {
45483       {
45484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45485       };
45486     } catch (...) {
45487       {
45488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45489       };
45490     }
45491   }
45492 }
45493
45494
45495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
45496   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45497   int arg2 ;
45498   std::vector< Dali::TouchPoint > *arg3 = 0 ;
45499
45500   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45501   arg2 = (int)jarg2;
45502   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
45503   if (!arg3) {
45504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45505     return ;
45506   }
45507   {
45508     try {
45509       try {
45510         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
45511       }
45512       catch(std::out_of_range &_e) {
45513         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45514         return ;
45515       }
45516
45517     } catch (std::out_of_range& e) {
45518       {
45519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45520       };
45521     } catch (std::exception& e) {
45522       {
45523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45524       };
45525     } catch (...) {
45526       {
45527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45528       };
45529     }
45530   }
45531 }
45532
45533
45534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
45535   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45536
45537   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45538   {
45539     try {
45540       delete arg1;
45541     } catch (std::out_of_range& e) {
45542       {
45543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45544       };
45545     } catch (std::exception& e) {
45546       {
45547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45548       };
45549     } catch (...) {
45550       {
45551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45552       };
45553     }
45554   }
45555 }
45556
45557
45558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
45559   void * jresult ;
45560   Dali::Rect< int > *result = 0 ;
45561
45562   {
45563     try {
45564       result = (Dali::Rect< int > *)new Dali::Rect< int >();
45565     } catch (std::out_of_range& e) {
45566       {
45567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45568       };
45569     } catch (std::exception& e) {
45570       {
45571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45572       };
45573     } catch (...) {
45574       {
45575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45576       };
45577     }
45578   }
45579   jresult = (void *)result;
45580   return jresult;
45581 }
45582
45583
45584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
45585   void * jresult ;
45586   int arg1 ;
45587   int arg2 ;
45588   int arg3 ;
45589   int arg4 ;
45590   Dali::Rect< int > *result = 0 ;
45591
45592   arg1 = (int)jarg1;
45593   arg2 = (int)jarg2;
45594   arg3 = (int)jarg3;
45595   arg4 = (int)jarg4;
45596   {
45597     try {
45598       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
45599     } catch (std::out_of_range& e) {
45600       {
45601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45602       };
45603     } catch (std::exception& e) {
45604       {
45605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45606       };
45607     } catch (...) {
45608       {
45609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45610       };
45611     }
45612   }
45613   jresult = (void *)result;
45614   return jresult;
45615 }
45616
45617
45618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
45619   void * jresult ;
45620   Dali::Rect< int > *arg1 = 0 ;
45621   Dali::Rect< int > *result = 0 ;
45622
45623   arg1 = (Dali::Rect< int > *)jarg1;
45624   if (!arg1) {
45625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45626     return 0;
45627   }
45628   {
45629     try {
45630       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
45631     } catch (std::out_of_range& e) {
45632       {
45633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45634       };
45635     } catch (std::exception& e) {
45636       {
45637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45638       };
45639     } catch (...) {
45640       {
45641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45642       };
45643     }
45644   }
45645   jresult = (void *)result;
45646   return jresult;
45647 }
45648
45649
45650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
45651   void * jresult ;
45652   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45653   Dali::Rect< int > *arg2 = 0 ;
45654   Dali::Rect< int > *result = 0 ;
45655
45656   arg1 = (Dali::Rect< int > *)jarg1;
45657   arg2 = (Dali::Rect< int > *)jarg2;
45658   if (!arg2) {
45659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45660     return 0;
45661   }
45662   {
45663     try {
45664       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
45665     } catch (std::out_of_range& e) {
45666       {
45667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (std::exception& e) {
45670       {
45671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45672       };
45673     } catch (...) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45676       };
45677     }
45678   }
45679   jresult = (void *)result;
45680   return jresult;
45681 }
45682
45683
45684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
45685   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45686   int arg2 ;
45687   int arg3 ;
45688   int arg4 ;
45689   int arg5 ;
45690
45691   arg1 = (Dali::Rect< int > *)jarg1;
45692   arg2 = (int)jarg2;
45693   arg3 = (int)jarg3;
45694   arg4 = (int)jarg4;
45695   arg5 = (int)jarg5;
45696   {
45697     try {
45698       (arg1)->Set(arg2,arg3,arg4,arg5);
45699     } catch (std::out_of_range& e) {
45700       {
45701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45702       };
45703     } catch (std::exception& e) {
45704       {
45705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45706       };
45707     } catch (...) {
45708       {
45709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45710       };
45711     }
45712   }
45713 }
45714
45715
45716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
45717   unsigned int jresult ;
45718   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45719   bool result;
45720
45721   arg1 = (Dali::Rect< int > *)jarg1;
45722   {
45723     try {
45724       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
45725     } catch (std::out_of_range& e) {
45726       {
45727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45728       };
45729     } catch (std::exception& e) {
45730       {
45731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45732       };
45733     } catch (...) {
45734       {
45735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45736       };
45737     }
45738   }
45739   jresult = result;
45740   return jresult;
45741 }
45742
45743
45744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
45745   int jresult ;
45746   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45747   int result;
45748
45749   arg1 = (Dali::Rect< int > *)jarg1;
45750   {
45751     try {
45752       result = (int)((Dali::Rect< int > const *)arg1)->Left();
45753     } catch (std::out_of_range& e) {
45754       {
45755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45756       };
45757     } catch (std::exception& e) {
45758       {
45759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45760       };
45761     } catch (...) {
45762       {
45763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45764       };
45765     }
45766   }
45767   jresult = result;
45768   return jresult;
45769 }
45770
45771
45772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
45773   int jresult ;
45774   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45775   int result;
45776
45777   arg1 = (Dali::Rect< int > *)jarg1;
45778   {
45779     try {
45780       result = (int)((Dali::Rect< int > const *)arg1)->Right();
45781     } catch (std::out_of_range& e) {
45782       {
45783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45784       };
45785     } catch (std::exception& e) {
45786       {
45787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45788       };
45789     } catch (...) {
45790       {
45791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45792       };
45793     }
45794   }
45795   jresult = result;
45796   return jresult;
45797 }
45798
45799
45800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
45801   int jresult ;
45802   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45803   int result;
45804
45805   arg1 = (Dali::Rect< int > *)jarg1;
45806   {
45807     try {
45808       result = (int)((Dali::Rect< int > const *)arg1)->Top();
45809     } catch (std::out_of_range& e) {
45810       {
45811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45812       };
45813     } catch (std::exception& e) {
45814       {
45815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45816       };
45817     } catch (...) {
45818       {
45819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45820       };
45821     }
45822   }
45823   jresult = result;
45824   return jresult;
45825 }
45826
45827
45828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
45829   int jresult ;
45830   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45831   int result;
45832
45833   arg1 = (Dali::Rect< int > *)jarg1;
45834   {
45835     try {
45836       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
45837     } catch (std::out_of_range& e) {
45838       {
45839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45840       };
45841     } catch (std::exception& e) {
45842       {
45843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45844       };
45845     } catch (...) {
45846       {
45847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45848       };
45849     }
45850   }
45851   jresult = result;
45852   return jresult;
45853 }
45854
45855
45856 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
45857   int jresult ;
45858   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45859   int result;
45860
45861   arg1 = (Dali::Rect< int > *)jarg1;
45862   {
45863     try {
45864       result = (int)((Dali::Rect< int > const *)arg1)->Area();
45865     } catch (std::out_of_range& e) {
45866       {
45867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45868       };
45869     } catch (std::exception& e) {
45870       {
45871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45872       };
45873     } catch (...) {
45874       {
45875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45876       };
45877     }
45878   }
45879   jresult = result;
45880   return jresult;
45881 }
45882
45883
45884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
45885   unsigned int jresult ;
45886   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45887   Dali::Rect< int > *arg2 = 0 ;
45888   bool result;
45889
45890   arg1 = (Dali::Rect< int > *)jarg1;
45891   arg2 = (Dali::Rect< int > *)jarg2;
45892   if (!arg2) {
45893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45894     return 0;
45895   }
45896   {
45897     try {
45898       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
45899     } catch (std::out_of_range& e) {
45900       {
45901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45902       };
45903     } catch (std::exception& e) {
45904       {
45905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45906       };
45907     } catch (...) {
45908       {
45909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45910       };
45911     }
45912   }
45913   jresult = result;
45914   return jresult;
45915 }
45916
45917
45918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
45919   unsigned int jresult ;
45920   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45921   Dali::Rect< int > *arg2 = 0 ;
45922   bool result;
45923
45924   arg1 = (Dali::Rect< int > *)jarg1;
45925   arg2 = (Dali::Rect< int > *)jarg2;
45926   if (!arg2) {
45927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
45928     return 0;
45929   }
45930   {
45931     try {
45932       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
45933     } catch (std::out_of_range& e) {
45934       {
45935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45936       };
45937     } catch (std::exception& e) {
45938       {
45939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45940       };
45941     } catch (...) {
45942       {
45943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45944       };
45945     }
45946   }
45947   jresult = result;
45948   return jresult;
45949 }
45950
45951
45952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
45953   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45954   int arg2 ;
45955
45956   arg1 = (Dali::Rect< int > *)jarg1;
45957   arg2 = (int)jarg2;
45958   if (arg1) (arg1)->x = arg2;
45959 }
45960
45961
45962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
45963   int jresult ;
45964   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45965   int result;
45966
45967   arg1 = (Dali::Rect< int > *)jarg1;
45968   result = (int) ((arg1)->x);
45969   jresult = result;
45970   return jresult;
45971 }
45972
45973
45974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
45975   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45976   int arg2 ;
45977
45978   arg1 = (Dali::Rect< int > *)jarg1;
45979   arg2 = (int)jarg2;
45980   if (arg1) (arg1)->left = arg2;
45981 }
45982
45983
45984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
45985   int jresult ;
45986   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45987   int result;
45988
45989   arg1 = (Dali::Rect< int > *)jarg1;
45990   result = (int) ((arg1)->left);
45991   jresult = result;
45992   return jresult;
45993 }
45994
45995
45996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
45997   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
45998   int arg2 ;
45999
46000   arg1 = (Dali::Rect< int > *)jarg1;
46001   arg2 = (int)jarg2;
46002   if (arg1) (arg1)->y = arg2;
46003 }
46004
46005
46006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
46007   int jresult ;
46008   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46009   int result;
46010
46011   arg1 = (Dali::Rect< int > *)jarg1;
46012   result = (int) ((arg1)->y);
46013   jresult = result;
46014   return jresult;
46015 }
46016
46017
46018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
46019   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46020   int arg2 ;
46021
46022   arg1 = (Dali::Rect< int > *)jarg1;
46023   arg2 = (int)jarg2;
46024   if (arg1) (arg1)->right = arg2;
46025 }
46026
46027
46028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
46029   int jresult ;
46030   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46031   int result;
46032
46033   arg1 = (Dali::Rect< int > *)jarg1;
46034   result = (int) ((arg1)->right);
46035   jresult = result;
46036   return jresult;
46037 }
46038
46039
46040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
46041   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46042   int arg2 ;
46043
46044   arg1 = (Dali::Rect< int > *)jarg1;
46045   arg2 = (int)jarg2;
46046   if (arg1) (arg1)->width = arg2;
46047 }
46048
46049
46050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
46051   int jresult ;
46052   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46053   int result;
46054
46055   arg1 = (Dali::Rect< int > *)jarg1;
46056   result = (int) ((arg1)->width);
46057   jresult = result;
46058   return jresult;
46059 }
46060
46061
46062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
46063   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46064   int arg2 ;
46065
46066   arg1 = (Dali::Rect< int > *)jarg1;
46067   arg2 = (int)jarg2;
46068   if (arg1) (arg1)->bottom = arg2;
46069 }
46070
46071
46072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
46073   int jresult ;
46074   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46075   int result;
46076
46077   arg1 = (Dali::Rect< int > *)jarg1;
46078   result = (int) ((arg1)->bottom);
46079   jresult = result;
46080   return jresult;
46081 }
46082
46083
46084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
46085   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46086   int arg2 ;
46087
46088   arg1 = (Dali::Rect< int > *)jarg1;
46089   arg2 = (int)jarg2;
46090   if (arg1) (arg1)->height = arg2;
46091 }
46092
46093
46094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
46095   int jresult ;
46096   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46097   int result;
46098
46099   arg1 = (Dali::Rect< int > *)jarg1;
46100   result = (int) ((arg1)->height);
46101   jresult = result;
46102   return jresult;
46103 }
46104
46105
46106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
46107   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46108   int arg2 ;
46109
46110   arg1 = (Dali::Rect< int > *)jarg1;
46111   arg2 = (int)jarg2;
46112   if (arg1) (arg1)->top = arg2;
46113 }
46114
46115
46116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
46117   int jresult ;
46118   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46119   int result;
46120
46121   arg1 = (Dali::Rect< int > *)jarg1;
46122   result = (int) ((arg1)->top);
46123   jresult = result;
46124   return jresult;
46125 }
46126
46127
46128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
46129   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46130
46131   arg1 = (Dali::Rect< int > *)jarg1;
46132   {
46133     try {
46134       delete arg1;
46135     } catch (std::out_of_range& e) {
46136       {
46137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46138       };
46139     } catch (std::exception& e) {
46140       {
46141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46142       };
46143     } catch (...) {
46144       {
46145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46146       };
46147     }
46148   }
46149 }
46150
46151
46152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
46153   void * jresult ;
46154   Dali::Rect< float > *result = 0 ;
46155
46156   {
46157     try {
46158       result = (Dali::Rect< float > *)new Dali::Rect< float >();
46159     } catch (std::out_of_range& e) {
46160       {
46161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46162       };
46163     } catch (std::exception& e) {
46164       {
46165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46166       };
46167     } catch (...) {
46168       {
46169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46170       };
46171     }
46172   }
46173   jresult = (void *)result;
46174   return jresult;
46175 }
46176
46177
46178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
46179   void * jresult ;
46180   float arg1 ;
46181   float arg2 ;
46182   float arg3 ;
46183   float arg4 ;
46184   Dali::Rect< float > *result = 0 ;
46185
46186   arg1 = (float)jarg1;
46187   arg2 = (float)jarg2;
46188   arg3 = (float)jarg3;
46189   arg4 = (float)jarg4;
46190   {
46191     try {
46192       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
46193     } catch (std::out_of_range& e) {
46194       {
46195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46196       };
46197     } catch (std::exception& e) {
46198       {
46199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46200       };
46201     } catch (...) {
46202       {
46203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46204       };
46205     }
46206   }
46207   jresult = (void *)result;
46208   return jresult;
46209 }
46210
46211
46212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
46213   void * jresult ;
46214   Dali::Rect< float > *arg1 = 0 ;
46215   Dali::Rect< float > *result = 0 ;
46216
46217   arg1 = (Dali::Rect< float > *)jarg1;
46218   if (!arg1) {
46219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46220     return 0;
46221   }
46222   {
46223     try {
46224       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
46225     } catch (std::out_of_range& e) {
46226       {
46227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46228       };
46229     } catch (std::exception& e) {
46230       {
46231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46232       };
46233     } catch (...) {
46234       {
46235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46236       };
46237     }
46238   }
46239   jresult = (void *)result;
46240   return jresult;
46241 }
46242
46243
46244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
46245   void * jresult ;
46246   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46247   Dali::Rect< float > *arg2 = 0 ;
46248   Dali::Rect< float > *result = 0 ;
46249
46250   arg1 = (Dali::Rect< float > *)jarg1;
46251   arg2 = (Dali::Rect< float > *)jarg2;
46252   if (!arg2) {
46253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
46254     return 0;
46255   }
46256   {
46257     try {
46258       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
46259     } catch (std::out_of_range& e) {
46260       {
46261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46262       };
46263     } catch (std::exception& e) {
46264       {
46265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46266       };
46267     } catch (...) {
46268       {
46269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46270       };
46271     }
46272   }
46273   jresult = (void *)result;
46274   return jresult;
46275 }
46276
46277
46278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
46279   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46280   float arg2 ;
46281   float arg3 ;
46282   float arg4 ;
46283   float arg5 ;
46284
46285   arg1 = (Dali::Rect< float > *)jarg1;
46286   arg2 = (float)jarg2;
46287   arg3 = (float)jarg3;
46288   arg4 = (float)jarg4;
46289   arg5 = (float)jarg5;
46290   {
46291     try {
46292       (arg1)->Set(arg2,arg3,arg4,arg5);
46293     } catch (std::out_of_range& e) {
46294       {
46295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46296       };
46297     } catch (std::exception& e) {
46298       {
46299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46300       };
46301     } catch (...) {
46302       {
46303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46304       };
46305     }
46306   }
46307 }
46308
46309
46310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_x_set(void * jarg1, float jarg2) {
46311   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46312   float arg2 ;
46313
46314   arg1 = (Dali::Rect< float > *)jarg1;
46315   arg2 = (float)jarg2;
46316   if (arg1) (arg1)->x = arg2;
46317 }
46318
46319
46320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_x_get(void * jarg1) {
46321   float jresult ;
46322   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46323   float result;
46324
46325   arg1 = (Dali::Rect< float > *)jarg1;
46326   result = (float) ((arg1)->x);
46327   jresult = result;
46328   return jresult;
46329 }
46330
46331
46332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
46333   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46334   float arg2 ;
46335
46336   arg1 = (Dali::Rect< float > *)jarg1;
46337   arg2 = (float)jarg2;
46338   if (arg1) (arg1)->left = arg2;
46339 }
46340
46341
46342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
46343   float jresult ;
46344   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46345   float result;
46346
46347   arg1 = (Dali::Rect< float > *)jarg1;
46348   result = (float) ((arg1)->left);
46349   jresult = result;
46350   return jresult;
46351 }
46352
46353
46354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_y_set(void * jarg1, float jarg2) {
46355   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46356   float arg2 ;
46357
46358   arg1 = (Dali::Rect< float > *)jarg1;
46359   arg2 = (float)jarg2;
46360   if (arg1) (arg1)->y = arg2;
46361 }
46362
46363
46364 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_y_get(void * jarg1) {
46365   float jresult ;
46366   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46367   float result;
46368
46369   arg1 = (Dali::Rect< float > *)jarg1;
46370   result = (float) ((arg1)->y);
46371   jresult = result;
46372   return jresult;
46373 }
46374
46375
46376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
46377   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46378   float arg2 ;
46379
46380   arg1 = (Dali::Rect< float > *)jarg1;
46381   arg2 = (float)jarg2;
46382   if (arg1) (arg1)->right = arg2;
46383 }
46384
46385
46386 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
46387   float jresult ;
46388   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46389   float result;
46390
46391   arg1 = (Dali::Rect< float > *)jarg1;
46392   result = (float) ((arg1)->right);
46393   jresult = result;
46394   return jresult;
46395 }
46396
46397
46398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_width_set(void * jarg1, float jarg2) {
46399   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46400   float arg2 ;
46401
46402   arg1 = (Dali::Rect< float > *)jarg1;
46403   arg2 = (float)jarg2;
46404   if (arg1) (arg1)->width = arg2;
46405 }
46406
46407
46408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_width_get(void * jarg1) {
46409   float jresult ;
46410   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46411   float result;
46412
46413   arg1 = (Dali::Rect< float > *)jarg1;
46414   result = (float) ((arg1)->width);
46415   jresult = result;
46416   return jresult;
46417 }
46418
46419
46420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
46421   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46422   float arg2 ;
46423
46424   arg1 = (Dali::Rect< float > *)jarg1;
46425   arg2 = (float)jarg2;
46426   if (arg1) (arg1)->bottom = arg2;
46427 }
46428
46429
46430 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
46431   float jresult ;
46432   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46433   float result;
46434
46435   arg1 = (Dali::Rect< float > *)jarg1;
46436   result = (float) ((arg1)->bottom);
46437   jresult = result;
46438   return jresult;
46439 }
46440
46441
46442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_height_set(void * jarg1, float jarg2) {
46443   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46444   float arg2 ;
46445
46446   arg1 = (Dali::Rect< float > *)jarg1;
46447   arg2 = (float)jarg2;
46448   if (arg1) (arg1)->height = arg2;
46449 }
46450
46451
46452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_height_get(void * jarg1) {
46453   float jresult ;
46454   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46455   float result;
46456
46457   arg1 = (Dali::Rect< float > *)jarg1;
46458   result = (float) ((arg1)->height);
46459   jresult = result;
46460   return jresult;
46461 }
46462
46463
46464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
46465   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46466   float arg2 ;
46467
46468   arg1 = (Dali::Rect< float > *)jarg1;
46469   arg2 = (float)jarg2;
46470   if (arg1) (arg1)->top = arg2;
46471 }
46472
46473
46474 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
46475   float jresult ;
46476   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46477   float result;
46478
46479   arg1 = (Dali::Rect< float > *)jarg1;
46480   result = (float) ((arg1)->top);
46481   jresult = result;
46482   return jresult;
46483 }
46484
46485
46486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
46487   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
46488
46489   arg1 = (Dali::Rect< float > *)jarg1;
46490   {
46491     try {
46492       delete arg1;
46493     } catch (std::out_of_range& e) {
46494       {
46495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46496       };
46497     } catch (std::exception& e) {
46498       {
46499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46500       };
46501     } catch (...) {
46502       {
46503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46504       };
46505     }
46506   }
46507 }
46508
46509
46510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
46511   int jresult ;
46512   int result;
46513
46514   result = (int)Dali::Vector< int >::BaseType;
46515   jresult = (int)result;
46516   return jresult;
46517 }
46518
46519
46520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
46521   void * jresult ;
46522   Dali::Vector< int > *result = 0 ;
46523
46524   {
46525     try {
46526       result = (Dali::Vector< int > *)new Dali::Vector< int >();
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_delete_VectorInteger(void * jarg1) {
46547   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46548
46549   arg1 = (Dali::Vector< int > *)jarg1;
46550   {
46551     try {
46552       delete arg1;
46553     } catch (std::out_of_range& e) {
46554       {
46555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46556       };
46557     } catch (std::exception& e) {
46558       {
46559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46560       };
46561     } catch (...) {
46562       {
46563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46564       };
46565     }
46566   }
46567 }
46568
46569
46570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
46571   void * jresult ;
46572   Dali::Vector< int > *arg1 = 0 ;
46573   Dali::Vector< int > *result = 0 ;
46574
46575   arg1 = (Dali::Vector< int > *)jarg1;
46576   if (!arg1) {
46577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46578     return 0;
46579   }
46580   {
46581     try {
46582       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
46583     } catch (std::out_of_range& e) {
46584       {
46585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46586       };
46587     } catch (std::exception& e) {
46588       {
46589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46590       };
46591     } catch (...) {
46592       {
46593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46594       };
46595     }
46596   }
46597   jresult = (void *)result;
46598   return jresult;
46599 }
46600
46601
46602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
46603   void * jresult ;
46604   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46605   Dali::Vector< int > *arg2 = 0 ;
46606   Dali::Vector< int > *result = 0 ;
46607
46608   arg1 = (Dali::Vector< int > *)jarg1;
46609   arg2 = (Dali::Vector< int > *)jarg2;
46610   if (!arg2) {
46611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
46612     return 0;
46613   }
46614   {
46615     try {
46616       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
46617     } catch (std::out_of_range& e) {
46618       {
46619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46620       };
46621     } catch (std::exception& e) {
46622       {
46623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46624       };
46625     } catch (...) {
46626       {
46627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46628       };
46629     }
46630   }
46631   jresult = (void *)result;
46632   return jresult;
46633 }
46634
46635
46636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
46637   void * jresult ;
46638   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46639   Dali::Vector< int >::Iterator result;
46640
46641   arg1 = (Dali::Vector< int > *)jarg1;
46642   {
46643     try {
46644       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
46645     } catch (std::out_of_range& e) {
46646       {
46647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46648       };
46649     } catch (std::exception& e) {
46650       {
46651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46652       };
46653     } catch (...) {
46654       {
46655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46656       };
46657     }
46658   }
46659   jresult = (void *)result;
46660   return jresult;
46661 }
46662
46663
46664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
46665   void * jresult ;
46666   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46667   Dali::Vector< int >::Iterator result;
46668
46669   arg1 = (Dali::Vector< int > *)jarg1;
46670   {
46671     try {
46672       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
46673     } catch (std::out_of_range& e) {
46674       {
46675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46676       };
46677     } catch (std::exception& e) {
46678       {
46679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46680       };
46681     } catch (...) {
46682       {
46683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46684       };
46685     }
46686   }
46687   jresult = (void *)result;
46688   return jresult;
46689 }
46690
46691
46692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
46693   void * jresult ;
46694   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46695   Dali::Vector< int >::SizeType arg2 ;
46696   Dali::Vector< int >::ItemType *result = 0 ;
46697
46698   arg1 = (Dali::Vector< int > *)jarg1;
46699   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46700   {
46701     try {
46702       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
46703     } catch (std::out_of_range& e) {
46704       {
46705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46706       };
46707     } catch (std::exception& e) {
46708       {
46709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46710       };
46711     } catch (...) {
46712       {
46713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46714       };
46715     }
46716   }
46717   jresult = (void *)result;
46718   return jresult;
46719 }
46720
46721
46722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
46723   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46724   Dali::Vector< int >::ItemType *arg2 = 0 ;
46725   Dali::Vector< int >::ItemType temp2 ;
46726
46727   arg1 = (Dali::Vector< int > *)jarg1;
46728   temp2 = (Dali::Vector< int >::ItemType)jarg2;
46729   arg2 = &temp2;
46730   {
46731     try {
46732       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
46733     } catch (std::out_of_range& e) {
46734       {
46735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46736       };
46737     } catch (std::exception& e) {
46738       {
46739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46740       };
46741     } catch (...) {
46742       {
46743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46744       };
46745     }
46746   }
46747 }
46748
46749
46750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
46751   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46752   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46753   Dali::Vector< int >::ItemType *arg3 = 0 ;
46754   Dali::Vector< int >::ItemType temp3 ;
46755
46756   arg1 = (Dali::Vector< int > *)jarg1;
46757   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46758   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46759   arg3 = &temp3;
46760   {
46761     try {
46762       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46763     } catch (std::out_of_range& e) {
46764       {
46765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46766       };
46767     } catch (std::exception& e) {
46768       {
46769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46770       };
46771     } catch (...) {
46772       {
46773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46774       };
46775     }
46776   }
46777 }
46778
46779
46780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
46781   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46782   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46783   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46784   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
46785
46786   arg1 = (Dali::Vector< int > *)jarg1;
46787   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46788   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46789   arg4 = (Dali::Vector< int >::Iterator)jarg4;
46790   {
46791     try {
46792       (arg1)->Insert(arg2,arg3,arg4);
46793     } catch (std::out_of_range& e) {
46794       {
46795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46796       };
46797     } catch (std::exception& e) {
46798       {
46799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46800       };
46801     } catch (...) {
46802       {
46803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46804       };
46805     }
46806   }
46807 }
46808
46809
46810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
46811   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46812   Dali::Vector< int >::SizeType arg2 ;
46813
46814   arg1 = (Dali::Vector< int > *)jarg1;
46815   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46816   {
46817     try {
46818       (arg1)->Reserve(arg2);
46819     } catch (std::out_of_range& e) {
46820       {
46821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46822       };
46823     } catch (std::exception& e) {
46824       {
46825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46826       };
46827     } catch (...) {
46828       {
46829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46830       };
46831     }
46832   }
46833 }
46834
46835
46836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
46837   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46838   Dali::Vector< int >::SizeType arg2 ;
46839
46840   arg1 = (Dali::Vector< int > *)jarg1;
46841   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46842   {
46843     try {
46844       (arg1)->Resize(arg2);
46845     } catch (std::out_of_range& e) {
46846       {
46847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46848       };
46849     } catch (std::exception& e) {
46850       {
46851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46852       };
46853     } catch (...) {
46854       {
46855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46856       };
46857     }
46858   }
46859 }
46860
46861
46862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
46863   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46864   Dali::Vector< int >::SizeType arg2 ;
46865   Dali::Vector< int >::ItemType *arg3 = 0 ;
46866   Dali::Vector< int >::ItemType temp3 ;
46867
46868   arg1 = (Dali::Vector< int > *)jarg1;
46869   arg2 = (Dali::Vector< int >::SizeType)jarg2;
46870   temp3 = (Dali::Vector< int >::ItemType)jarg3;
46871   arg3 = &temp3;
46872   {
46873     try {
46874       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
46875     } catch (std::out_of_range& e) {
46876       {
46877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46878       };
46879     } catch (std::exception& e) {
46880       {
46881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46882       };
46883     } catch (...) {
46884       {
46885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46886       };
46887     }
46888   }
46889 }
46890
46891
46892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
46893   void * jresult ;
46894   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46895   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46896   Dali::Vector< int >::Iterator result;
46897
46898   arg1 = (Dali::Vector< int > *)jarg1;
46899   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46900   {
46901     try {
46902       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
46903     } catch (std::out_of_range& e) {
46904       {
46905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46906       };
46907     } catch (std::exception& e) {
46908       {
46909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46910       };
46911     } catch (...) {
46912       {
46913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46914       };
46915     }
46916   }
46917   jresult = (void *)result;
46918   return jresult;
46919 }
46920
46921
46922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
46923   void * jresult ;
46924   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46925   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46926   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
46927   Dali::Vector< int >::Iterator result;
46928
46929   arg1 = (Dali::Vector< int > *)jarg1;
46930   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46931   arg3 = (Dali::Vector< int >::Iterator)jarg3;
46932   {
46933     try {
46934       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
46935     } catch (std::out_of_range& e) {
46936       {
46937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46938       };
46939     } catch (std::exception& e) {
46940       {
46941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46942       };
46943     } catch (...) {
46944       {
46945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46946       };
46947     }
46948   }
46949   jresult = (void *)result;
46950   return jresult;
46951 }
46952
46953
46954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
46955   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46956   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
46957
46958   arg1 = (Dali::Vector< int > *)jarg1;
46959   arg2 = (Dali::Vector< int >::Iterator)jarg2;
46960   {
46961     try {
46962       (arg1)->Remove(arg2);
46963     } catch (std::out_of_range& e) {
46964       {
46965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46966       };
46967     } catch (std::exception& e) {
46968       {
46969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46970       };
46971     } catch (...) {
46972       {
46973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46974       };
46975     }
46976   }
46977 }
46978
46979
46980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
46981   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
46982   Dali::Vector< int > *arg2 = 0 ;
46983
46984   arg1 = (Dali::Vector< int > *)jarg1;
46985   arg2 = (Dali::Vector< int > *)jarg2;
46986   if (!arg2) {
46987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
46988     return ;
46989   }
46990   {
46991     try {
46992       (arg1)->Swap(*arg2);
46993     } catch (std::out_of_range& e) {
46994       {
46995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46996       };
46997     } catch (std::exception& e) {
46998       {
46999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47000       };
47001     } catch (...) {
47002       {
47003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47004       };
47005     }
47006   }
47007 }
47008
47009
47010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
47011   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47012
47013   arg1 = (Dali::Vector< int > *)jarg1;
47014   {
47015     try {
47016       (arg1)->Clear();
47017     } catch (std::out_of_range& e) {
47018       {
47019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47020       };
47021     } catch (std::exception& e) {
47022       {
47023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47024       };
47025     } catch (...) {
47026       {
47027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47028       };
47029     }
47030   }
47031 }
47032
47033
47034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
47035   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47036
47037   arg1 = (Dali::Vector< int > *)jarg1;
47038   {
47039     try {
47040       (arg1)->Release();
47041     } catch (std::out_of_range& e) {
47042       {
47043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47044       };
47045     } catch (std::exception& e) {
47046       {
47047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47048       };
47049     } catch (...) {
47050       {
47051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47052       };
47053     }
47054   }
47055 }
47056
47057
47058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
47059   int jresult ;
47060   int result;
47061
47062   result = (int)Dali::Vector< float >::BaseType;
47063   jresult = (int)result;
47064   return jresult;
47065 }
47066
47067
47068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
47069   void * jresult ;
47070   Dali::Vector< float > *result = 0 ;
47071
47072   {
47073     try {
47074       result = (Dali::Vector< float > *)new Dali::Vector< float >();
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_delete_VectorFloat(void * jarg1) {
47095   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47096
47097   arg1 = (Dali::Vector< float > *)jarg1;
47098   {
47099     try {
47100       delete arg1;
47101     } catch (std::out_of_range& e) {
47102       {
47103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47104       };
47105     } catch (std::exception& e) {
47106       {
47107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47108       };
47109     } catch (...) {
47110       {
47111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47112       };
47113     }
47114   }
47115 }
47116
47117
47118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
47119   void * jresult ;
47120   Dali::Vector< float > *arg1 = 0 ;
47121   Dali::Vector< float > *result = 0 ;
47122
47123   arg1 = (Dali::Vector< float > *)jarg1;
47124   if (!arg1) {
47125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47126     return 0;
47127   }
47128   {
47129     try {
47130       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
47131     } catch (std::out_of_range& e) {
47132       {
47133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47134       };
47135     } catch (std::exception& e) {
47136       {
47137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47138       };
47139     } catch (...) {
47140       {
47141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47142       };
47143     }
47144   }
47145   jresult = (void *)result;
47146   return jresult;
47147 }
47148
47149
47150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
47151   void * jresult ;
47152   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47153   Dali::Vector< float > *arg2 = 0 ;
47154   Dali::Vector< float > *result = 0 ;
47155
47156   arg1 = (Dali::Vector< float > *)jarg1;
47157   arg2 = (Dali::Vector< float > *)jarg2;
47158   if (!arg2) {
47159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
47160     return 0;
47161   }
47162   {
47163     try {
47164       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
47165     } catch (std::out_of_range& e) {
47166       {
47167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47168       };
47169     } catch (std::exception& e) {
47170       {
47171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47172       };
47173     } catch (...) {
47174       {
47175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47176       };
47177     }
47178   }
47179   jresult = (void *)result;
47180   return jresult;
47181 }
47182
47183
47184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
47185   void * jresult ;
47186   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47187   Dali::Vector< float >::Iterator result;
47188
47189   arg1 = (Dali::Vector< float > *)jarg1;
47190   {
47191     try {
47192       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
47193     } catch (std::out_of_range& e) {
47194       {
47195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47196       };
47197     } catch (std::exception& e) {
47198       {
47199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47200       };
47201     } catch (...) {
47202       {
47203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47204       };
47205     }
47206   }
47207   jresult = (void *)result;
47208   return jresult;
47209 }
47210
47211
47212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
47213   void * jresult ;
47214   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47215   Dali::Vector< float >::Iterator result;
47216
47217   arg1 = (Dali::Vector< float > *)jarg1;
47218   {
47219     try {
47220       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
47221     } catch (std::out_of_range& e) {
47222       {
47223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47224       };
47225     } catch (std::exception& e) {
47226       {
47227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47228       };
47229     } catch (...) {
47230       {
47231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47232       };
47233     }
47234   }
47235   jresult = (void *)result;
47236   return jresult;
47237 }
47238
47239
47240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47241   void * jresult ;
47242   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47243   Dali::Vector< float >::SizeType arg2 ;
47244   Dali::Vector< float >::ItemType *result = 0 ;
47245
47246   arg1 = (Dali::Vector< float > *)jarg1;
47247   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47248   {
47249     try {
47250       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
47251     } catch (std::out_of_range& e) {
47252       {
47253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47254       };
47255     } catch (std::exception& e) {
47256       {
47257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47258       };
47259     } catch (...) {
47260       {
47261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47262       };
47263     }
47264   }
47265   jresult = (void *)result;
47266   return jresult;
47267 }
47268
47269
47270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
47271   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47272   Dali::Vector< float >::ItemType *arg2 = 0 ;
47273   Dali::Vector< float >::ItemType temp2 ;
47274
47275   arg1 = (Dali::Vector< float > *)jarg1;
47276   temp2 = (Dali::Vector< float >::ItemType)jarg2;
47277   arg2 = &temp2;
47278   {
47279     try {
47280       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
47281     } catch (std::out_of_range& e) {
47282       {
47283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47284       };
47285     } catch (std::exception& e) {
47286       {
47287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47288       };
47289     } catch (...) {
47290       {
47291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47292       };
47293     }
47294   }
47295 }
47296
47297
47298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
47299   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47300   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47301   Dali::Vector< float >::ItemType *arg3 = 0 ;
47302   Dali::Vector< float >::ItemType temp3 ;
47303
47304   arg1 = (Dali::Vector< float > *)jarg1;
47305   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47306   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47307   arg3 = &temp3;
47308   {
47309     try {
47310       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47311     } catch (std::out_of_range& e) {
47312       {
47313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47314       };
47315     } catch (std::exception& e) {
47316       {
47317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47318       };
47319     } catch (...) {
47320       {
47321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47322       };
47323     }
47324   }
47325 }
47326
47327
47328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47329   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47330   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47331   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47332   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
47333
47334   arg1 = (Dali::Vector< float > *)jarg1;
47335   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47336   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47337   arg4 = (Dali::Vector< float >::Iterator)jarg4;
47338   {
47339     try {
47340       (arg1)->Insert(arg2,arg3,arg4);
47341     } catch (std::out_of_range& e) {
47342       {
47343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47344       };
47345     } catch (std::exception& e) {
47346       {
47347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47348       };
47349     } catch (...) {
47350       {
47351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47352       };
47353     }
47354   }
47355 }
47356
47357
47358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
47359   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47360   Dali::Vector< float >::SizeType arg2 ;
47361
47362   arg1 = (Dali::Vector< float > *)jarg1;
47363   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47364   {
47365     try {
47366       (arg1)->Reserve(arg2);
47367     } catch (std::out_of_range& e) {
47368       {
47369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47370       };
47371     } catch (std::exception& e) {
47372       {
47373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47374       };
47375     } catch (...) {
47376       {
47377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47378       };
47379     }
47380   }
47381 }
47382
47383
47384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47385   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47386   Dali::Vector< float >::SizeType arg2 ;
47387
47388   arg1 = (Dali::Vector< float > *)jarg1;
47389   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47390   {
47391     try {
47392       (arg1)->Resize(arg2);
47393     } catch (std::out_of_range& e) {
47394       {
47395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47396       };
47397     } catch (std::exception& e) {
47398       {
47399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47400       };
47401     } catch (...) {
47402       {
47403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47404       };
47405     }
47406   }
47407 }
47408
47409
47410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
47411   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47412   Dali::Vector< float >::SizeType arg2 ;
47413   Dali::Vector< float >::ItemType *arg3 = 0 ;
47414   Dali::Vector< float >::ItemType temp3 ;
47415
47416   arg1 = (Dali::Vector< float > *)jarg1;
47417   arg2 = (Dali::Vector< float >::SizeType)jarg2;
47418   temp3 = (Dali::Vector< float >::ItemType)jarg3;
47419   arg3 = &temp3;
47420   {
47421     try {
47422       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
47423     } catch (std::out_of_range& e) {
47424       {
47425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47426       };
47427     } catch (std::exception& e) {
47428       {
47429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47430       };
47431     } catch (...) {
47432       {
47433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47434       };
47435     }
47436   }
47437 }
47438
47439
47440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
47441   void * jresult ;
47442   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47443   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47444   Dali::Vector< float >::Iterator result;
47445
47446   arg1 = (Dali::Vector< float > *)jarg1;
47447   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47448   {
47449     try {
47450       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
47451     } catch (std::out_of_range& e) {
47452       {
47453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47454       };
47455     } catch (std::exception& e) {
47456       {
47457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47458       };
47459     } catch (...) {
47460       {
47461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47462       };
47463     }
47464   }
47465   jresult = (void *)result;
47466   return jresult;
47467 }
47468
47469
47470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
47471   void * jresult ;
47472   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47473   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47474   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
47475   Dali::Vector< float >::Iterator result;
47476
47477   arg1 = (Dali::Vector< float > *)jarg1;
47478   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47479   arg3 = (Dali::Vector< float >::Iterator)jarg3;
47480   {
47481     try {
47482       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
47483     } catch (std::out_of_range& e) {
47484       {
47485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47486       };
47487     } catch (std::exception& e) {
47488       {
47489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47490       };
47491     } catch (...) {
47492       {
47493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47494       };
47495     }
47496   }
47497   jresult = (void *)result;
47498   return jresult;
47499 }
47500
47501
47502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
47503   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47504   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
47505
47506   arg1 = (Dali::Vector< float > *)jarg1;
47507   arg2 = (Dali::Vector< float >::Iterator)jarg2;
47508   {
47509     try {
47510       (arg1)->Remove(arg2);
47511     } catch (std::out_of_range& e) {
47512       {
47513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47514       };
47515     } catch (std::exception& e) {
47516       {
47517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47518       };
47519     } catch (...) {
47520       {
47521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47522       };
47523     }
47524   }
47525 }
47526
47527
47528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
47529   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47530   Dali::Vector< float > *arg2 = 0 ;
47531
47532   arg1 = (Dali::Vector< float > *)jarg1;
47533   arg2 = (Dali::Vector< float > *)jarg2;
47534   if (!arg2) {
47535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
47536     return ;
47537   }
47538   {
47539     try {
47540       (arg1)->Swap(*arg2);
47541     } catch (std::out_of_range& e) {
47542       {
47543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47544       };
47545     } catch (std::exception& e) {
47546       {
47547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47548       };
47549     } catch (...) {
47550       {
47551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47552       };
47553     }
47554   }
47555 }
47556
47557
47558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
47559   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47560
47561   arg1 = (Dali::Vector< float > *)jarg1;
47562   {
47563     try {
47564       (arg1)->Clear();
47565     } catch (std::out_of_range& e) {
47566       {
47567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47568       };
47569     } catch (std::exception& e) {
47570       {
47571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47572       };
47573     } catch (...) {
47574       {
47575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47576       };
47577     }
47578   }
47579 }
47580
47581
47582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
47583   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
47584
47585   arg1 = (Dali::Vector< float > *)jarg1;
47586   {
47587     try {
47588       (arg1)->Release();
47589     } catch (std::out_of_range& e) {
47590       {
47591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47592       };
47593     } catch (std::exception& e) {
47594       {
47595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47596       };
47597     } catch (...) {
47598       {
47599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47600       };
47601     }
47602   }
47603 }
47604
47605
47606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
47607   int jresult ;
47608   int result;
47609
47610   result = (int)Dali::Vector< unsigned char >::BaseType;
47611   jresult = (int)result;
47612   return jresult;
47613 }
47614
47615
47616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
47617   void * jresult ;
47618   Dali::Vector< unsigned char > *result = 0 ;
47619
47620   {
47621     try {
47622       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
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_delete_VectorUnsignedChar(void * jarg1) {
47643   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47644
47645   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47646   {
47647     try {
47648       delete arg1;
47649     } catch (std::out_of_range& e) {
47650       {
47651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47652       };
47653     } catch (std::exception& e) {
47654       {
47655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47656       };
47657     } catch (...) {
47658       {
47659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47660       };
47661     }
47662   }
47663 }
47664
47665
47666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
47667   void * jresult ;
47668   Dali::Vector< unsigned char > *arg1 = 0 ;
47669   Dali::Vector< unsigned char > *result = 0 ;
47670
47671   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47672   if (!arg1) {
47673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47674     return 0;
47675   }
47676   {
47677     try {
47678       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
47679     } catch (std::out_of_range& e) {
47680       {
47681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47682       };
47683     } catch (std::exception& e) {
47684       {
47685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47686       };
47687     } catch (...) {
47688       {
47689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47690       };
47691     }
47692   }
47693   jresult = (void *)result;
47694   return jresult;
47695 }
47696
47697
47698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
47699   void * jresult ;
47700   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47701   Dali::Vector< unsigned char > *arg2 = 0 ;
47702   Dali::Vector< unsigned char > *result = 0 ;
47703
47704   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47705   arg2 = (Dali::Vector< unsigned char > *)jarg2;
47706   if (!arg2) {
47707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
47708     return 0;
47709   }
47710   {
47711     try {
47712       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
47713     } catch (std::out_of_range& e) {
47714       {
47715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47716       };
47717     } catch (std::exception& e) {
47718       {
47719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47720       };
47721     } catch (...) {
47722       {
47723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47724       };
47725     }
47726   }
47727   jresult = (void *)result;
47728   return jresult;
47729 }
47730
47731
47732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
47733   void * jresult ;
47734   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47735   Dali::Vector< unsigned char >::Iterator result;
47736
47737   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47738   {
47739     try {
47740       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
47741     } catch (std::out_of_range& e) {
47742       {
47743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47744       };
47745     } catch (std::exception& e) {
47746       {
47747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47748       };
47749     } catch (...) {
47750       {
47751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47752       };
47753     }
47754   }
47755   jresult = (void *)result;
47756   return jresult;
47757 }
47758
47759
47760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
47761   void * jresult ;
47762   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47763   Dali::Vector< unsigned char >::Iterator result;
47764
47765   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47766   {
47767     try {
47768       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
47769     } catch (std::out_of_range& e) {
47770       {
47771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47772       };
47773     } catch (std::exception& e) {
47774       {
47775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47776       };
47777     } catch (...) {
47778       {
47779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47780       };
47781     }
47782   }
47783   jresult = (void *)result;
47784   return jresult;
47785 }
47786
47787
47788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47789   void * jresult ;
47790   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47791   Dali::Vector< unsigned char >::SizeType arg2 ;
47792   Dali::Vector< unsigned char >::ItemType *result = 0 ;
47793
47794   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47795   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47796   {
47797     try {
47798       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
47799     } catch (std::out_of_range& e) {
47800       {
47801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47802       };
47803     } catch (std::exception& e) {
47804       {
47805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47806       };
47807     } catch (...) {
47808       {
47809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47810       };
47811     }
47812   }
47813   jresult = (void *)result;
47814   return jresult;
47815 }
47816
47817
47818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
47819   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47820   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
47821   Dali::Vector< unsigned char >::ItemType temp2 ;
47822
47823   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47824   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
47825   arg2 = &temp2;
47826   {
47827     try {
47828       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
47829     } catch (std::out_of_range& e) {
47830       {
47831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47832       };
47833     } catch (std::exception& e) {
47834       {
47835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47836       };
47837     } catch (...) {
47838       {
47839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47840       };
47841     }
47842   }
47843 }
47844
47845
47846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
47847   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47848   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47849   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47850   Dali::Vector< unsigned char >::ItemType temp3 ;
47851
47852   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47853   arg2 = jarg2;
47854   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47855   arg3 = &temp3;
47856   {
47857     try {
47858       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47859     } catch (std::out_of_range& e) {
47860       {
47861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47862       };
47863     } catch (std::exception& e) {
47864       {
47865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47866       };
47867     } catch (...) {
47868       {
47869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47870       };
47871     }
47872   }
47873
47874
47875 }
47876
47877
47878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
47879   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47880   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47881   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47882   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47883
47884   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47885   arg2 = jarg2;
47886   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
47887   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
47888   {
47889     try {
47890       (arg1)->Insert(arg2,arg3,arg4);
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_Reserve(void * jarg1, unsigned long jarg2) {
47911   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47912   Dali::Vector< unsigned char >::SizeType arg2 ;
47913
47914   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47915   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47916   {
47917     try {
47918       (arg1)->Reserve(arg2);
47919     } catch (std::out_of_range& e) {
47920       {
47921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47922       };
47923     } catch (std::exception& e) {
47924       {
47925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47926       };
47927     } catch (...) {
47928       {
47929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47930       };
47931     }
47932   }
47933 }
47934
47935
47936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47937   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47938   Dali::Vector< unsigned char >::SizeType arg2 ;
47939
47940   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47941   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47942   {
47943     try {
47944       (arg1)->Resize(arg2);
47945     } catch (std::out_of_range& e) {
47946       {
47947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47948       };
47949     } catch (std::exception& e) {
47950       {
47951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47952       };
47953     } catch (...) {
47954       {
47955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47956       };
47957     }
47958   }
47959 }
47960
47961
47962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
47963   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47964   Dali::Vector< unsigned char >::SizeType arg2 ;
47965   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
47966   Dali::Vector< unsigned char >::ItemType temp3 ;
47967
47968   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47969   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
47970   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
47971   arg3 = &temp3;
47972   {
47973     try {
47974       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
47975     } catch (std::out_of_range& e) {
47976       {
47977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47978       };
47979     } catch (std::exception& e) {
47980       {
47981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47982       };
47983     } catch (...) {
47984       {
47985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47986       };
47987     }
47988   }
47989 }
47990
47991
47992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
47993   void * jresult ;
47994   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
47995   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
47996   Dali::Vector< unsigned char >::Iterator result;
47997
47998   arg1 = (Dali::Vector< unsigned char > *)jarg1;
47999   arg2 = jarg2;
48000   {
48001     try {
48002       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
48003     } catch (std::out_of_range& e) {
48004       {
48005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48006       };
48007     } catch (std::exception& e) {
48008       {
48009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48010       };
48011     } catch (...) {
48012       {
48013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48014       };
48015     }
48016   }
48017   jresult = (void *)result;
48018
48019
48020   return jresult;
48021 }
48022
48023
48024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
48025   void * jresult ;
48026   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48027   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48028   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48029   Dali::Vector< unsigned char >::Iterator result;
48030
48031   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48032   arg2 = jarg2;
48033   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
48034   {
48035     try {
48036       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
48037     } catch (std::out_of_range& e) {
48038       {
48039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48040       };
48041     } catch (std::exception& e) {
48042       {
48043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48044       };
48045     } catch (...) {
48046       {
48047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48048       };
48049     }
48050   }
48051   jresult = (void *)result;
48052
48053
48054   return jresult;
48055 }
48056
48057
48058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
48059   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48060   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
48061
48062   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48063   arg2 = jarg2;
48064   {
48065     try {
48066       (arg1)->Remove(arg2);
48067     } catch (std::out_of_range& e) {
48068       {
48069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48070       };
48071     } catch (std::exception& e) {
48072       {
48073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48074       };
48075     } catch (...) {
48076       {
48077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48078       };
48079     }
48080   }
48081
48082
48083 }
48084
48085
48086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
48087   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48088   Dali::Vector< unsigned char > *arg2 = 0 ;
48089
48090   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48091   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48092   if (!arg2) {
48093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
48094     return ;
48095   }
48096   {
48097     try {
48098       (arg1)->Swap(*arg2);
48099     } catch (std::out_of_range& e) {
48100       {
48101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48102       };
48103     } catch (std::exception& e) {
48104       {
48105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48106       };
48107     } catch (...) {
48108       {
48109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48110       };
48111     }
48112   }
48113 }
48114
48115
48116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
48117   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48118
48119   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48120   {
48121     try {
48122       (arg1)->Clear();
48123     } catch (std::out_of_range& e) {
48124       {
48125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48126       };
48127     } catch (std::exception& e) {
48128       {
48129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48130       };
48131     } catch (...) {
48132       {
48133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48134       };
48135     }
48136   }
48137 }
48138
48139
48140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
48141   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48142
48143   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48144   {
48145     try {
48146       (arg1)->Release();
48147     } catch (std::out_of_range& e) {
48148       {
48149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48150       };
48151     } catch (std::exception& e) {
48152       {
48153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48154       };
48155     } catch (...) {
48156       {
48157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48158       };
48159     }
48160   }
48161 }
48162
48163
48164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
48165   int jresult ;
48166   int result;
48167
48168   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
48169   jresult = (int)result;
48170   return jresult;
48171 }
48172
48173
48174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
48175   void * jresult ;
48176   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48177
48178   {
48179     try {
48180       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
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_delete_VectorUint16Pair(void * jarg1) {
48201   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48202
48203   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48204   {
48205     try {
48206       delete arg1;
48207     } catch (std::out_of_range& e) {
48208       {
48209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48210       };
48211     } catch (std::exception& e) {
48212       {
48213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48214       };
48215     } catch (...) {
48216       {
48217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48218       };
48219     }
48220   }
48221 }
48222
48223
48224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
48225   void * jresult ;
48226   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
48227   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48228
48229   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48230   if (!arg1) {
48231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48232     return 0;
48233   }
48234   {
48235     try {
48236       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
48237     } catch (std::out_of_range& e) {
48238       {
48239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48240       };
48241     } catch (std::exception& e) {
48242       {
48243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48244       };
48245     } catch (...) {
48246       {
48247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48248       };
48249     }
48250   }
48251   jresult = (void *)result;
48252   return jresult;
48253 }
48254
48255
48256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
48257   void * jresult ;
48258   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48259   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48260   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
48261
48262   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48263   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48264   if (!arg2) {
48265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
48266     return 0;
48267   }
48268   {
48269     try {
48270       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
48271     } catch (std::out_of_range& e) {
48272       {
48273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48274       };
48275     } catch (std::exception& e) {
48276       {
48277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48278       };
48279     } catch (...) {
48280       {
48281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48282       };
48283     }
48284   }
48285   jresult = (void *)result;
48286   return jresult;
48287 }
48288
48289
48290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
48291   void * jresult ;
48292   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48293   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48294
48295   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48296   {
48297     try {
48298       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
48299     } catch (std::out_of_range& e) {
48300       {
48301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48302       };
48303     } catch (std::exception& e) {
48304       {
48305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48306       };
48307     } catch (...) {
48308       {
48309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48310       };
48311     }
48312   }
48313   jresult = (void *)result;
48314   return jresult;
48315 }
48316
48317
48318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
48319   void * jresult ;
48320   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48321   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48322
48323   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48324   {
48325     try {
48326       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
48327     } catch (std::out_of_range& e) {
48328       {
48329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48330       };
48331     } catch (std::exception& e) {
48332       {
48333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48334       };
48335     } catch (...) {
48336       {
48337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48338       };
48339     }
48340   }
48341   jresult = (void *)result;
48342   return jresult;
48343 }
48344
48345
48346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48347   void * jresult ;
48348   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48349   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48350   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
48351
48352   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48353   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48354   {
48355     try {
48356       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
48357     } catch (std::out_of_range& e) {
48358       {
48359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48360       };
48361     } catch (std::exception& e) {
48362       {
48363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48364       };
48365     } catch (...) {
48366       {
48367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48368       };
48369     }
48370   }
48371   jresult = (void *)result;
48372   return jresult;
48373 }
48374
48375
48376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
48377   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48378   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
48379
48380   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48381   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
48382   if (!arg2) {
48383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48384     return ;
48385   }
48386   {
48387     try {
48388       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
48389     } catch (std::out_of_range& e) {
48390       {
48391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48392       };
48393     } catch (std::exception& e) {
48394       {
48395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48396       };
48397     } catch (...) {
48398       {
48399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48400       };
48401     }
48402   }
48403 }
48404
48405
48406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
48407   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48408   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48409   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48410
48411   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48412   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48413   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48414   if (!arg3) {
48415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48416     return ;
48417   }
48418   {
48419     try {
48420       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48421     } catch (std::out_of_range& e) {
48422       {
48423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48424       };
48425     } catch (std::exception& e) {
48426       {
48427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48428       };
48429     } catch (...) {
48430       {
48431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48432       };
48433     }
48434   }
48435 }
48436
48437
48438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
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   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48442   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48443
48444   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48445   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48446   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48447   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
48448   {
48449     try {
48450       (arg1)->Insert(arg2,arg3,arg4);
48451     } catch (std::out_of_range& e) {
48452       {
48453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48454       };
48455     } catch (std::exception& e) {
48456       {
48457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48458       };
48459     } catch (...) {
48460       {
48461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48462       };
48463     }
48464   }
48465 }
48466
48467
48468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
48469   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48470   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48471
48472   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48473   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48474   {
48475     try {
48476       (arg1)->Reserve(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_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48495   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48496   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48497
48498   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48499   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48500   {
48501     try {
48502       (arg1)->Resize(arg2);
48503     } catch (std::out_of_range& e) {
48504       {
48505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48506       };
48507     } catch (std::exception& e) {
48508       {
48509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48510       };
48511     } catch (...) {
48512       {
48513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48514       };
48515     }
48516   }
48517 }
48518
48519
48520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
48521   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48522   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
48523   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
48524
48525   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48526   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
48527   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
48528   if (!arg3) {
48529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
48530     return ;
48531   }
48532   {
48533     try {
48534       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
48535     } catch (std::out_of_range& e) {
48536       {
48537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48538       };
48539     } catch (std::exception& e) {
48540       {
48541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48542       };
48543     } catch (...) {
48544       {
48545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48546       };
48547     }
48548   }
48549 }
48550
48551
48552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
48553   void * jresult ;
48554   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48555   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48556   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48557
48558   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48559   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48560   {
48561     try {
48562       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
48563     } catch (std::out_of_range& e) {
48564       {
48565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48566       };
48567     } catch (std::exception& e) {
48568       {
48569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48570       };
48571     } catch (...) {
48572       {
48573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48574       };
48575     }
48576   }
48577   jresult = (void *)result;
48578   return jresult;
48579 }
48580
48581
48582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48583   void * jresult ;
48584   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48585   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48586   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48587   Dali::Vector< Dali::Uint16Pair >::Iterator result;
48588
48589   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48590   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48591   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
48592   {
48593     try {
48594       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
48595     } catch (std::out_of_range& e) {
48596       {
48597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48598       };
48599     } catch (std::exception& e) {
48600       {
48601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48602       };
48603     } catch (...) {
48604       {
48605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48606       };
48607     }
48608   }
48609   jresult = (void *)result;
48610   return jresult;
48611 }
48612
48613
48614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
48615   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48616   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
48617
48618   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48619   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
48620   {
48621     try {
48622       (arg1)->Remove(arg2);
48623     } catch (std::out_of_range& e) {
48624       {
48625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48626       };
48627     } catch (std::exception& e) {
48628       {
48629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48630       };
48631     } catch (...) {
48632       {
48633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48634       };
48635     }
48636   }
48637 }
48638
48639
48640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
48641   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48642   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
48643
48644   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48645   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
48646   if (!arg2) {
48647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
48648     return ;
48649   }
48650   {
48651     try {
48652       (arg1)->Swap(*arg2);
48653     } catch (std::out_of_range& e) {
48654       {
48655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48656       };
48657     } catch (std::exception& e) {
48658       {
48659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48660       };
48661     } catch (...) {
48662       {
48663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48664       };
48665     }
48666   }
48667 }
48668
48669
48670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
48671   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48672
48673   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48674   {
48675     try {
48676       (arg1)->Clear();
48677     } catch (std::out_of_range& e) {
48678       {
48679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48680       };
48681     } catch (std::exception& e) {
48682       {
48683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48684       };
48685     } catch (...) {
48686       {
48687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48688       };
48689     }
48690   }
48691 }
48692
48693
48694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
48695   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
48696
48697   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
48698   {
48699     try {
48700       (arg1)->Release();
48701     } catch (std::out_of_range& e) {
48702       {
48703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48704       };
48705     } catch (std::exception& e) {
48706       {
48707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48708       };
48709     } catch (...) {
48710       {
48711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48712       };
48713     }
48714   }
48715 }
48716
48717
48718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
48719   void * jresult ;
48720   Dali::Signal< void () > *result = 0 ;
48721
48722   {
48723     try {
48724       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
48725     } catch (std::out_of_range& e) {
48726       {
48727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48728       };
48729     } catch (std::exception& e) {
48730       {
48731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48732       };
48733     } catch (...) {
48734       {
48735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48736       };
48737     }
48738   }
48739   jresult = (void *)result;
48740   return jresult;
48741 }
48742
48743
48744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
48745   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48746
48747   arg1 = (Dali::Signal< void () > *)jarg1;
48748   {
48749     try {
48750       delete arg1;
48751     } catch (std::out_of_range& e) {
48752       {
48753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48754       };
48755     } catch (std::exception& e) {
48756       {
48757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48758       };
48759     } catch (...) {
48760       {
48761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48762       };
48763     }
48764   }
48765 }
48766
48767
48768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
48769   unsigned int jresult ;
48770   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48771   bool result;
48772
48773   arg1 = (Dali::Signal< void () > *)jarg1;
48774   {
48775     try {
48776       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
48777     } catch (std::out_of_range& e) {
48778       {
48779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48780       };
48781     } catch (std::exception& e) {
48782       {
48783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48784       };
48785     } catch (...) {
48786       {
48787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48788       };
48789     }
48790   }
48791   jresult = result;
48792   return jresult;
48793 }
48794
48795
48796 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
48797   unsigned long jresult ;
48798   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48799   std::size_t result;
48800
48801   arg1 = (Dali::Signal< void () > *)jarg1;
48802   {
48803     try {
48804       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
48805     } catch (std::out_of_range& e) {
48806       {
48807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48808       };
48809     } catch (std::exception& e) {
48810       {
48811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48812       };
48813     } catch (...) {
48814       {
48815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48816       };
48817     }
48818   }
48819   jresult = (unsigned long)result;
48820   return jresult;
48821 }
48822
48823
48824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
48825   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48826   void (*arg2)() = (void (*)()) 0 ;
48827
48828   arg1 = (Dali::Signal< void () > *)jarg1;
48829   arg2 = (void (*)())jarg2;
48830   {
48831     try {
48832       (arg1)->Connect(arg2);
48833     } catch (std::out_of_range& e) {
48834       {
48835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48836       };
48837     } catch (std::exception& e) {
48838       {
48839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48840       };
48841     } catch (...) {
48842       {
48843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48844       };
48845     }
48846   }
48847 }
48848
48849
48850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
48851   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48852   void (*arg2)() = (void (*)()) 0 ;
48853
48854   arg1 = (Dali::Signal< void () > *)jarg1;
48855   arg2 = (void (*)())jarg2;
48856   {
48857     try {
48858       (arg1)->Disconnect(arg2);
48859     } catch (std::out_of_range& e) {
48860       {
48861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48862       };
48863     } catch (std::exception& e) {
48864       {
48865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48866       };
48867     } catch (...) {
48868       {
48869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48870       };
48871     }
48872   }
48873 }
48874
48875
48876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
48877   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48878   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
48879   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
48880
48881   arg1 = (Dali::Signal< void () > *)jarg1;
48882   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
48883   arg3 = (Dali::FunctorDelegate *)jarg3;
48884   {
48885     try {
48886       (arg1)->Connect(arg2,arg3);
48887     } catch (std::out_of_range& e) {
48888       {
48889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48890       };
48891     } catch (std::exception& e) {
48892       {
48893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48894       };
48895     } catch (...) {
48896       {
48897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48898       };
48899     }
48900   }
48901 }
48902
48903
48904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
48905   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
48906
48907   arg1 = (Dali::Signal< void () > *)jarg1;
48908   {
48909     try {
48910       (arg1)->Emit();
48911     } catch (std::out_of_range& e) {
48912       {
48913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48914       };
48915     } catch (std::exception& e) {
48916       {
48917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48918       };
48919     } catch (...) {
48920       {
48921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48922       };
48923     }
48924   }
48925 }
48926
48927
48928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
48929   unsigned int jresult ;
48930   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48931   bool result;
48932
48933   arg1 = (Dali::Signal< void (float) > *)jarg1;
48934   {
48935     try {
48936       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
48937     } catch (std::out_of_range& e) {
48938       {
48939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48940       };
48941     } catch (std::exception& e) {
48942       {
48943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48944       };
48945     } catch (...) {
48946       {
48947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48948       };
48949     }
48950   }
48951   jresult = result;
48952   return jresult;
48953 }
48954
48955
48956 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
48957   unsigned long jresult ;
48958   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48959   std::size_t result;
48960
48961   arg1 = (Dali::Signal< void (float) > *)jarg1;
48962   {
48963     try {
48964       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
48965     } catch (std::out_of_range& e) {
48966       {
48967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48968       };
48969     } catch (std::exception& e) {
48970       {
48971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48972       };
48973     } catch (...) {
48974       {
48975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48976       };
48977     }
48978   }
48979   jresult = (unsigned long)result;
48980   return jresult;
48981 }
48982
48983
48984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
48985   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
48986   void (*arg2)(float) = (void (*)(float)) 0 ;
48987
48988   arg1 = (Dali::Signal< void (float) > *)jarg1;
48989   arg2 = (void (*)(float))jarg2;
48990   {
48991     try {
48992       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
48993     } catch (std::out_of_range& e) {
48994       {
48995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48996       };
48997     } catch (std::exception& e) {
48998       {
48999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49000       };
49001     } catch (...) {
49002       {
49003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49004       };
49005     }
49006   }
49007 }
49008
49009
49010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
49011   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49012   void (*arg2)(float) = (void (*)(float)) 0 ;
49013
49014   arg1 = (Dali::Signal< void (float) > *)jarg1;
49015   arg2 = (void (*)(float))jarg2;
49016   {
49017     try {
49018       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
49019     } catch (std::out_of_range& e) {
49020       {
49021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49022       };
49023     } catch (std::exception& e) {
49024       {
49025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49026       };
49027     } catch (...) {
49028       {
49029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49030       };
49031     }
49032   }
49033 }
49034
49035
49036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
49037   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49038   float arg2 ;
49039
49040   arg1 = (Dali::Signal< void (float) > *)jarg1;
49041   arg2 = (float)jarg2;
49042   {
49043     try {
49044       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
49045     } catch (std::out_of_range& e) {
49046       {
49047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49048       };
49049     } catch (std::exception& e) {
49050       {
49051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49052       };
49053     } catch (...) {
49054       {
49055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49056       };
49057     }
49058   }
49059 }
49060
49061
49062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
49063   void * jresult ;
49064   Dali::Signal< void (float) > *result = 0 ;
49065
49066   {
49067     try {
49068       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
49069     } catch (std::out_of_range& e) {
49070       {
49071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49072       };
49073     } catch (std::exception& e) {
49074       {
49075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49076       };
49077     } catch (...) {
49078       {
49079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49080       };
49081     }
49082   }
49083   jresult = (void *)result;
49084   return jresult;
49085 }
49086
49087
49088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
49089   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
49090
49091   arg1 = (Dali::Signal< void (float) > *)jarg1;
49092   {
49093     try {
49094       delete arg1;
49095     } catch (std::out_of_range& e) {
49096       {
49097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49098       };
49099     } catch (std::exception& e) {
49100       {
49101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49102       };
49103     } catch (...) {
49104       {
49105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49106       };
49107     }
49108   }
49109 }
49110
49111
49112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
49113   unsigned int jresult ;
49114   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49115   bool result;
49116
49117   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49118   {
49119     try {
49120       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49121     } catch (std::out_of_range& e) {
49122       {
49123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49124       };
49125     } catch (std::exception& e) {
49126       {
49127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49128       };
49129     } catch (...) {
49130       {
49131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49132       };
49133     }
49134   }
49135   jresult = result;
49136   return jresult;
49137 }
49138
49139
49140 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
49141   unsigned long jresult ;
49142   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49143   std::size_t result;
49144
49145   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49146   {
49147     try {
49148       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
49149     } catch (std::out_of_range& e) {
49150       {
49151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49152       };
49153     } catch (std::exception& e) {
49154       {
49155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49156       };
49157     } catch (...) {
49158       {
49159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49160       };
49161     }
49162   }
49163   jresult = (unsigned long)result;
49164   return jresult;
49165 }
49166
49167
49168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
49169   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49170   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49171
49172   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49173   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49174   {
49175     try {
49176       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
49177     } catch (std::out_of_range& e) {
49178       {
49179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49180       };
49181     } catch (std::exception& e) {
49182       {
49183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49184       };
49185     } catch (...) {
49186       {
49187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49188       };
49189     }
49190   }
49191 }
49192
49193
49194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
49195   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49196   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
49197
49198   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49199   arg2 = (void (*)(Dali::BaseHandle))jarg2;
49200   {
49201     try {
49202       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
49203     } catch (std::out_of_range& e) {
49204       {
49205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49206       };
49207     } catch (std::exception& e) {
49208       {
49209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49210       };
49211     } catch (...) {
49212       {
49213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49214       };
49215     }
49216   }
49217 }
49218
49219
49220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
49221   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49222   Dali::BaseHandle arg2 ;
49223   Dali::BaseHandle *argp2 ;
49224
49225   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49226   argp2 = (Dali::BaseHandle *)jarg2;
49227   if (!argp2) {
49228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
49229     return ;
49230   }
49231   arg2 = *argp2;
49232   {
49233     try {
49234       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
49235     } catch (std::out_of_range& e) {
49236       {
49237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49238       };
49239     } catch (std::exception& e) {
49240       {
49241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49242       };
49243     } catch (...) {
49244       {
49245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49246       };
49247     }
49248   }
49249 }
49250
49251
49252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
49253   void * jresult ;
49254   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
49255
49256   {
49257     try {
49258       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
49259     } catch (std::out_of_range& e) {
49260       {
49261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49262       };
49263     } catch (std::exception& e) {
49264       {
49265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49266       };
49267     } catch (...) {
49268       {
49269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49270       };
49271     }
49272   }
49273   jresult = (void *)result;
49274   return jresult;
49275 }
49276
49277
49278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
49279   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
49280
49281   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
49282   {
49283     try {
49284       delete arg1;
49285     } catch (std::out_of_range& e) {
49286       {
49287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49288       };
49289     } catch (std::exception& e) {
49290       {
49291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49292       };
49293     } catch (...) {
49294       {
49295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49296       };
49297     }
49298   }
49299 }
49300
49301
49302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
49303   unsigned int jresult ;
49304   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49305   bool result;
49306
49307   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49308   {
49309     try {
49310       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49311     } catch (std::out_of_range& e) {
49312       {
49313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49314       };
49315     } catch (std::exception& e) {
49316       {
49317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49318       };
49319     } catch (...) {
49320       {
49321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49322       };
49323     }
49324   }
49325   jresult = result;
49326   return jresult;
49327 }
49328
49329
49330 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
49331   unsigned long jresult ;
49332   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49333   std::size_t result;
49334
49335   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49336   {
49337     try {
49338       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
49339     } catch (std::out_of_range& e) {
49340       {
49341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49342       };
49343     } catch (std::exception& e) {
49344       {
49345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49346       };
49347     } catch (...) {
49348       {
49349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49350       };
49351     }
49352   }
49353   jresult = (unsigned long)result;
49354   return jresult;
49355 }
49356
49357
49358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
49359   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49360   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49361
49362   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49363   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49364   {
49365     try {
49366       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
49367     } catch (std::out_of_range& e) {
49368       {
49369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49370       };
49371     } catch (std::exception& e) {
49372       {
49373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49374       };
49375     } catch (...) {
49376       {
49377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49378       };
49379     }
49380   }
49381 }
49382
49383
49384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
49385   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49386   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
49387
49388   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49389   arg2 = (void (*)(Dali::RefObject const *))jarg2;
49390   {
49391     try {
49392       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
49393     } catch (std::out_of_range& e) {
49394       {
49395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49396       };
49397     } catch (std::exception& e) {
49398       {
49399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49400       };
49401     } catch (...) {
49402       {
49403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49404       };
49405     }
49406   }
49407 }
49408
49409
49410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
49411   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49412   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
49413
49414   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49415   arg2 = (Dali::RefObject *)jarg2;
49416   {
49417     try {
49418       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
49419     } catch (std::out_of_range& e) {
49420       {
49421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49422       };
49423     } catch (std::exception& e) {
49424       {
49425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49426       };
49427     } catch (...) {
49428       {
49429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49430       };
49431     }
49432   }
49433 }
49434
49435
49436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
49437   void * jresult ;
49438   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
49439
49440   {
49441     try {
49442       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
49443     } catch (std::out_of_range& e) {
49444       {
49445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49446       };
49447     } catch (std::exception& e) {
49448       {
49449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49450       };
49451     } catch (...) {
49452       {
49453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49454       };
49455     }
49456   }
49457   jresult = (void *)result;
49458   return jresult;
49459 }
49460
49461
49462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
49463   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
49464
49465   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
49466   {
49467     try {
49468       delete arg1;
49469     } catch (std::out_of_range& e) {
49470       {
49471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49472       };
49473     } catch (std::exception& e) {
49474       {
49475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49476       };
49477     } catch (...) {
49478       {
49479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49480       };
49481     }
49482   }
49483 }
49484
49485
49486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
49487   unsigned int jresult ;
49488   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49489   bool result;
49490
49491   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49492   {
49493     try {
49494       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49495     } catch (std::out_of_range& e) {
49496       {
49497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49498       };
49499     } catch (std::exception& e) {
49500       {
49501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49502       };
49503     } catch (...) {
49504       {
49505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49506       };
49507     }
49508   }
49509   jresult = result;
49510   return jresult;
49511 }
49512
49513
49514 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
49515   unsigned long jresult ;
49516   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49517   std::size_t result;
49518
49519   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49520   {
49521     try {
49522       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
49523     } catch (std::out_of_range& e) {
49524       {
49525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49526       };
49527     } catch (std::exception& e) {
49528       {
49529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49530       };
49531     } catch (...) {
49532       {
49533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49534       };
49535     }
49536   }
49537   jresult = (unsigned long)result;
49538   return jresult;
49539 }
49540
49541
49542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
49543   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49544   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49545
49546   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49547   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49548   {
49549     try {
49550       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
49551     } catch (std::out_of_range& e) {
49552       {
49553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49554       };
49555     } catch (std::exception& e) {
49556       {
49557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49558       };
49559     } catch (...) {
49560       {
49561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49562       };
49563     }
49564   }
49565 }
49566
49567
49568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
49569   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49570   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
49571
49572   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49573   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
49574   {
49575     try {
49576       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
49577     } catch (std::out_of_range& e) {
49578       {
49579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49580       };
49581     } catch (std::exception& e) {
49582       {
49583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49584       };
49585     } catch (...) {
49586       {
49587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49588       };
49589     }
49590   }
49591 }
49592
49593
49594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
49595   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49596   Dali::PropertyNotification *arg2 = 0 ;
49597
49598   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49599   arg2 = (Dali::PropertyNotification *)jarg2;
49600   if (!arg2) {
49601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
49602     return ;
49603   }
49604   {
49605     try {
49606       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
49607     } catch (std::out_of_range& e) {
49608       {
49609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49610       };
49611     } catch (std::exception& e) {
49612       {
49613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49614       };
49615     } catch (...) {
49616       {
49617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49618       };
49619     }
49620   }
49621 }
49622
49623
49624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
49625   void * jresult ;
49626   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
49627
49628   {
49629     try {
49630       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
49631     } catch (std::out_of_range& e) {
49632       {
49633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49634       };
49635     } catch (std::exception& e) {
49636       {
49637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49638       };
49639     } catch (...) {
49640       {
49641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49642       };
49643     }
49644   }
49645   jresult = (void *)result;
49646   return jresult;
49647 }
49648
49649
49650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
49651   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
49652
49653   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
49654   {
49655     try {
49656       delete arg1;
49657     } catch (std::out_of_range& e) {
49658       {
49659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49660       };
49661     } catch (std::exception& e) {
49662       {
49663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49664       };
49665     } catch (...) {
49666       {
49667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49668       };
49669     }
49670   }
49671 }
49672
49673
49674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
49675   unsigned int jresult ;
49676   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49677   bool result;
49678
49679   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49680   {
49681     try {
49682       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
49683     } catch (std::out_of_range& e) {
49684       {
49685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49686       };
49687     } catch (std::exception& e) {
49688       {
49689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49690       };
49691     } catch (...) {
49692       {
49693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49694       };
49695     }
49696   }
49697   jresult = result;
49698   return jresult;
49699 }
49700
49701
49702 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
49703   unsigned long jresult ;
49704   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49705   std::size_t result;
49706
49707   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49708   {
49709     try {
49710       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
49711     } catch (std::out_of_range& e) {
49712       {
49713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49714       };
49715     } catch (std::exception& e) {
49716       {
49717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49718       };
49719     } catch (...) {
49720       {
49721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49722       };
49723     }
49724   }
49725   jresult = (unsigned long)result;
49726   return jresult;
49727 }
49728
49729
49730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
49731   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49732   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49733
49734   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49735   arg2 = (void (*)(Dali::Image))jarg2;
49736   {
49737     try {
49738       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
49739     } catch (std::out_of_range& e) {
49740       {
49741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49742       };
49743     } catch (std::exception& e) {
49744       {
49745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49746       };
49747     } catch (...) {
49748       {
49749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49750       };
49751     }
49752   }
49753 }
49754
49755
49756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
49757   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49758   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
49759
49760   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49761   arg2 = (void (*)(Dali::Image))jarg2;
49762   {
49763     try {
49764       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
49765     } catch (std::out_of_range& e) {
49766       {
49767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49768       };
49769     } catch (std::exception& e) {
49770       {
49771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49772       };
49773     } catch (...) {
49774       {
49775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49776       };
49777     }
49778   }
49779 }
49780
49781
49782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
49783   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49784   Dali::Image arg2 ;
49785   Dali::Image *argp2 ;
49786
49787   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49788   argp2 = (Dali::Image *)jarg2;
49789   if (!argp2) {
49790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
49791     return ;
49792   }
49793   arg2 = *argp2;
49794   {
49795     try {
49796       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
49797     } catch (std::out_of_range& e) {
49798       {
49799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49800       };
49801     } catch (std::exception& e) {
49802       {
49803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49804       };
49805     } catch (...) {
49806       {
49807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49808       };
49809     }
49810   }
49811 }
49812
49813
49814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
49815   void * jresult ;
49816   Dali::Signal< void (Dali::Image) > *result = 0 ;
49817
49818   {
49819     try {
49820       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
49821     } catch (std::out_of_range& e) {
49822       {
49823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49824       };
49825     } catch (std::exception& e) {
49826       {
49827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49828       };
49829     } catch (...) {
49830       {
49831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49832       };
49833     }
49834   }
49835   jresult = (void *)result;
49836   return jresult;
49837 }
49838
49839
49840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
49841   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
49842
49843   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
49844   {
49845     try {
49846       delete arg1;
49847     } catch (std::out_of_range& e) {
49848       {
49849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49850       };
49851     } catch (std::exception& e) {
49852       {
49853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49854       };
49855     } catch (...) {
49856       {
49857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49858       };
49859     }
49860   }
49861 }
49862
49863
49864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
49865   void * jresult ;
49866   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
49867
49868   {
49869     try {
49870       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
49871     } catch (std::out_of_range& e) {
49872       {
49873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49874       };
49875     } catch (std::exception& e) {
49876       {
49877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49878       };
49879     } catch (...) {
49880       {
49881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49882       };
49883     }
49884   }
49885   jresult = (void *)result;
49886   return jresult;
49887 }
49888
49889
49890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
49891   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
49892
49893   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
49894   {
49895     try {
49896       delete arg1;
49897     } catch (std::out_of_range& e) {
49898       {
49899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49900       };
49901     } catch (std::exception& e) {
49902       {
49903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49904       };
49905     } catch (...) {
49906       {
49907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49908       };
49909     }
49910   }
49911 }
49912
49913
49914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
49915   unsigned int jresult ;
49916   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49917   bool result;
49918
49919   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49920   {
49921     try {
49922       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);
49923     } catch (std::out_of_range& e) {
49924       {
49925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49926       };
49927     } catch (std::exception& e) {
49928       {
49929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49930       };
49931     } catch (...) {
49932       {
49933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49934       };
49935     }
49936   }
49937   jresult = result;
49938   return jresult;
49939 }
49940
49941
49942 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
49943   unsigned long jresult ;
49944   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49945   std::size_t result;
49946
49947   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49948   {
49949     try {
49950       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);
49951     } catch (std::out_of_range& e) {
49952       {
49953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49954       };
49955     } catch (std::exception& e) {
49956       {
49957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49958       };
49959     } catch (...) {
49960       {
49961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49962       };
49963     }
49964   }
49965   jresult = (unsigned long)result;
49966   return jresult;
49967 }
49968
49969
49970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
49971   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49972   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49973
49974   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
49975   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
49976   {
49977     try {
49978       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
49979     } catch (std::out_of_range& e) {
49980       {
49981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49982       };
49983     } catch (std::exception& e) {
49984       {
49985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49986       };
49987     } catch (...) {
49988       {
49989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49990       };
49991     }
49992   }
49993 }
49994
49995
49996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
49997   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
49998   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
49999
50000   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50001   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
50002   {
50003     try {
50004       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50005     } catch (std::out_of_range& e) {
50006       {
50007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50008       };
50009     } catch (std::exception& e) {
50010       {
50011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50012       };
50013     } catch (...) {
50014       {
50015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50016       };
50017     }
50018   }
50019 }
50020
50021
50022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50023   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50024   Dali::Actor arg2 ;
50025   Dali::LongPressGesture *arg3 = 0 ;
50026   Dali::Actor *argp2 ;
50027
50028   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50029   argp2 = (Dali::Actor *)jarg2;
50030   if (!argp2) {
50031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50032     return ;
50033   }
50034   arg2 = *argp2;
50035   arg3 = (Dali::LongPressGesture *)jarg3;
50036   if (!arg3) {
50037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
50038     return ;
50039   }
50040   {
50041     try {
50042       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
50043     } catch (std::out_of_range& e) {
50044       {
50045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50046       };
50047     } catch (std::exception& e) {
50048       {
50049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50050       };
50051     } catch (...) {
50052       {
50053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50054       };
50055     }
50056   }
50057 }
50058
50059
50060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
50061   void * jresult ;
50062   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
50063
50064   {
50065     try {
50066       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
50067     } catch (std::out_of_range& e) {
50068       {
50069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50070       };
50071     } catch (std::exception& e) {
50072       {
50073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50074       };
50075     } catch (...) {
50076       {
50077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50078       };
50079     }
50080   }
50081   jresult = (void *)result;
50082   return jresult;
50083 }
50084
50085
50086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
50087   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
50088
50089   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
50090   {
50091     try {
50092       delete arg1;
50093     } catch (std::out_of_range& e) {
50094       {
50095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50096       };
50097     } catch (std::exception& e) {
50098       {
50099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50100       };
50101     } catch (...) {
50102       {
50103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50104       };
50105     }
50106   }
50107 }
50108
50109
50110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
50111   unsigned int jresult ;
50112   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50113   bool result;
50114
50115   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50116   {
50117     try {
50118       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);
50119     } catch (std::out_of_range& e) {
50120       {
50121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50122       };
50123     } catch (std::exception& e) {
50124       {
50125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50126       };
50127     } catch (...) {
50128       {
50129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50130       };
50131     }
50132   }
50133   jresult = result;
50134   return jresult;
50135 }
50136
50137
50138 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
50139   unsigned long jresult ;
50140   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50141   std::size_t result;
50142
50143   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50144   {
50145     try {
50146       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);
50147     } catch (std::out_of_range& e) {
50148       {
50149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50150       };
50151     } catch (std::exception& e) {
50152       {
50153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50154       };
50155     } catch (...) {
50156       {
50157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50158       };
50159     }
50160   }
50161   jresult = (unsigned long)result;
50162   return jresult;
50163 }
50164
50165
50166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
50167   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50168   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50169
50170   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50171   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50172   {
50173     try {
50174       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50175     } catch (std::out_of_range& e) {
50176       {
50177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50178       };
50179     } catch (std::exception& e) {
50180       {
50181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50182       };
50183     } catch (...) {
50184       {
50185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50186       };
50187     }
50188   }
50189 }
50190
50191
50192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
50193   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50194   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
50195
50196   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50197   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
50198   {
50199     try {
50200       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50201     } catch (std::out_of_range& e) {
50202       {
50203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50204       };
50205     } catch (std::exception& e) {
50206       {
50207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50208       };
50209     } catch (...) {
50210       {
50211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50212       };
50213     }
50214   }
50215 }
50216
50217
50218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50219   unsigned int jresult ;
50220   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50221   Dali::Actor arg2 ;
50222   Dali::TouchData *arg3 = 0 ;
50223   Dali::Actor *argp2 ;
50224   bool result;
50225
50226   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50227   argp2 = (Dali::Actor *)jarg2;
50228   if (!argp2) {
50229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50230     return 0;
50231   }
50232   arg2 = *argp2;
50233   arg3 = (Dali::TouchData *)jarg3;
50234   if (!arg3) {
50235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
50236     return 0;
50237   }
50238   {
50239     try {
50240       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
50241     } catch (std::out_of_range& e) {
50242       {
50243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50244       };
50245     } catch (std::exception& e) {
50246       {
50247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50248       };
50249     } catch (...) {
50250       {
50251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50252       };
50253     }
50254   }
50255   jresult = result;
50256   return jresult;
50257 }
50258
50259
50260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
50261   void * jresult ;
50262   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
50263
50264   {
50265     try {
50266       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
50267     } catch (std::out_of_range& e) {
50268       {
50269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50270       };
50271     } catch (std::exception& e) {
50272       {
50273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50274       };
50275     } catch (...) {
50276       {
50277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50278       };
50279     }
50280   }
50281   jresult = (void *)result;
50282   return jresult;
50283 }
50284
50285
50286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
50287   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
50288
50289   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
50290   {
50291     try {
50292       delete arg1;
50293     } catch (std::out_of_range& e) {
50294       {
50295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50296       };
50297     } catch (std::exception& e) {
50298       {
50299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50300       };
50301     } catch (...) {
50302       {
50303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50304       };
50305     }
50306   }
50307 }
50308
50309
50310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
50311   unsigned int jresult ;
50312   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50313   bool result;
50314
50315   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50316   {
50317     try {
50318       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);
50319     } catch (std::out_of_range& e) {
50320       {
50321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50322       };
50323     } catch (std::exception& e) {
50324       {
50325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50326       };
50327     } catch (...) {
50328       {
50329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50330       };
50331     }
50332   }
50333   jresult = result;
50334   return jresult;
50335 }
50336
50337
50338 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
50339   unsigned long jresult ;
50340   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50341   std::size_t result;
50342
50343   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50344   {
50345     try {
50346       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);
50347     } catch (std::out_of_range& e) {
50348       {
50349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50350       };
50351     } catch (std::exception& e) {
50352       {
50353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50354       };
50355     } catch (...) {
50356       {
50357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50358       };
50359     }
50360   }
50361   jresult = (unsigned long)result;
50362   return jresult;
50363 }
50364
50365
50366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
50367   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50368   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50369
50370   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50371   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50372   {
50373     try {
50374       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50375     } catch (std::out_of_range& e) {
50376       {
50377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50378       };
50379     } catch (std::exception& e) {
50380       {
50381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50382       };
50383     } catch (...) {
50384       {
50385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50386       };
50387     }
50388   }
50389 }
50390
50391
50392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
50393   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50394   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
50395
50396   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50397   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
50398   {
50399     try {
50400       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50401     } catch (std::out_of_range& e) {
50402       {
50403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50404       };
50405     } catch (std::exception& e) {
50406       {
50407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50408       };
50409     } catch (...) {
50410       {
50411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50412       };
50413     }
50414   }
50415 }
50416
50417
50418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50419   unsigned int jresult ;
50420   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50421   Dali::Actor arg2 ;
50422   Dali::HoverEvent *arg3 = 0 ;
50423   Dali::Actor *argp2 ;
50424   bool result;
50425
50426   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50427   argp2 = (Dali::Actor *)jarg2;
50428   if (!argp2) {
50429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50430     return 0;
50431   }
50432   arg2 = *argp2;
50433   arg3 = (Dali::HoverEvent *)jarg3;
50434   if (!arg3) {
50435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
50436     return 0;
50437   }
50438   {
50439     try {
50440       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
50441     } catch (std::out_of_range& e) {
50442       {
50443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50444       };
50445     } catch (std::exception& e) {
50446       {
50447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50448       };
50449     } catch (...) {
50450       {
50451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50452       };
50453     }
50454   }
50455   jresult = result;
50456   return jresult;
50457 }
50458
50459
50460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
50461   void * jresult ;
50462   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
50463
50464   {
50465     try {
50466       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
50467     } catch (std::out_of_range& e) {
50468       {
50469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50470       };
50471     } catch (std::exception& e) {
50472       {
50473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50474       };
50475     } catch (...) {
50476       {
50477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50478       };
50479     }
50480   }
50481   jresult = (void *)result;
50482   return jresult;
50483 }
50484
50485
50486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
50487   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
50488
50489   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
50490   {
50491     try {
50492       delete arg1;
50493     } catch (std::out_of_range& e) {
50494       {
50495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50496       };
50497     } catch (std::exception& e) {
50498       {
50499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50500       };
50501     } catch (...) {
50502       {
50503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50504       };
50505     }
50506   }
50507 }
50508
50509
50510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
50511   unsigned int jresult ;
50512   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50513   bool result;
50514
50515   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50516   {
50517     try {
50518       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);
50519     } catch (std::out_of_range& e) {
50520       {
50521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50522       };
50523     } catch (std::exception& e) {
50524       {
50525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50526       };
50527     } catch (...) {
50528       {
50529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50530       };
50531     }
50532   }
50533   jresult = result;
50534   return jresult;
50535 }
50536
50537
50538 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
50539   unsigned long jresult ;
50540   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50541   std::size_t result;
50542
50543   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50544   {
50545     try {
50546       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);
50547     } catch (std::out_of_range& e) {
50548       {
50549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50550       };
50551     } catch (std::exception& e) {
50552       {
50553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50554       };
50555     } catch (...) {
50556       {
50557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50558       };
50559     }
50560   }
50561   jresult = (unsigned long)result;
50562   return jresult;
50563 }
50564
50565
50566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
50567   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50568   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50569
50570   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50571   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50572   {
50573     try {
50574       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50575     } catch (std::out_of_range& e) {
50576       {
50577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50578       };
50579     } catch (std::exception& e) {
50580       {
50581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50582       };
50583     } catch (...) {
50584       {
50585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50586       };
50587     }
50588   }
50589 }
50590
50591
50592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
50593   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50594   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
50595
50596   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50597   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
50598   {
50599     try {
50600       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50601     } catch (std::out_of_range& e) {
50602       {
50603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50604       };
50605     } catch (std::exception& e) {
50606       {
50607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50608       };
50609     } catch (...) {
50610       {
50611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50612       };
50613     }
50614   }
50615 }
50616
50617
50618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
50619   unsigned int jresult ;
50620   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50621   Dali::Actor arg2 ;
50622   Dali::WheelEvent *arg3 = 0 ;
50623   Dali::Actor *argp2 ;
50624   bool result;
50625
50626   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50627   argp2 = (Dali::Actor *)jarg2;
50628   if (!argp2) {
50629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50630     return 0;
50631   }
50632   arg2 = *argp2;
50633   arg3 = (Dali::WheelEvent *)jarg3;
50634   if (!arg3) {
50635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
50636     return 0;
50637   }
50638   {
50639     try {
50640       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
50641     } catch (std::out_of_range& e) {
50642       {
50643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50644       };
50645     } catch (std::exception& e) {
50646       {
50647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50648       };
50649     } catch (...) {
50650       {
50651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50652       };
50653     }
50654   }
50655   jresult = result;
50656   return jresult;
50657 }
50658
50659
50660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
50661   void * jresult ;
50662   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
50663
50664   {
50665     try {
50666       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
50667     } catch (std::out_of_range& e) {
50668       {
50669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50670       };
50671     } catch (std::exception& e) {
50672       {
50673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50674       };
50675     } catch (...) {
50676       {
50677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50678       };
50679     }
50680   }
50681   jresult = (void *)result;
50682   return jresult;
50683 }
50684
50685
50686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
50687   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
50688
50689   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
50690   {
50691     try {
50692       delete arg1;
50693     } catch (std::out_of_range& e) {
50694       {
50695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50696       };
50697     } catch (std::exception& e) {
50698       {
50699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50700       };
50701     } catch (...) {
50702       {
50703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50704       };
50705     }
50706   }
50707 }
50708
50709
50710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
50711   unsigned int jresult ;
50712   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50713   bool result;
50714
50715   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50716   {
50717     try {
50718       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
50719     } catch (std::out_of_range& e) {
50720       {
50721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50722       };
50723     } catch (std::exception& e) {
50724       {
50725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50726       };
50727     } catch (...) {
50728       {
50729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50730       };
50731     }
50732   }
50733   jresult = result;
50734   return jresult;
50735 }
50736
50737
50738 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
50739   unsigned long jresult ;
50740   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50741   std::size_t result;
50742
50743   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50744   {
50745     try {
50746       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
50747     } catch (std::out_of_range& e) {
50748       {
50749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50750       };
50751     } catch (std::exception& e) {
50752       {
50753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50754       };
50755     } catch (...) {
50756       {
50757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50758       };
50759     }
50760   }
50761   jresult = (unsigned long)result;
50762   return jresult;
50763 }
50764
50765
50766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
50767   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50768   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50769
50770   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50771   arg2 = (void (*)(Dali::Actor))jarg2;
50772   {
50773     try {
50774       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
50775     } catch (std::out_of_range& e) {
50776       {
50777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50778       };
50779     } catch (std::exception& e) {
50780       {
50781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50782       };
50783     } catch (...) {
50784       {
50785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50786       };
50787     }
50788   }
50789 }
50790
50791
50792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
50793   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50794   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
50795
50796   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50797   arg2 = (void (*)(Dali::Actor))jarg2;
50798   {
50799     try {
50800       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
50801     } catch (std::out_of_range& e) {
50802       {
50803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50804       };
50805     } catch (std::exception& e) {
50806       {
50807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50808       };
50809     } catch (...) {
50810       {
50811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50812       };
50813     }
50814   }
50815 }
50816
50817
50818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
50819   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50820   Dali::Actor arg2 ;
50821   Dali::Actor *argp2 ;
50822
50823   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50824   argp2 = (Dali::Actor *)jarg2;
50825   if (!argp2) {
50826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
50827     return ;
50828   }
50829   arg2 = *argp2;
50830   {
50831     try {
50832       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
50833     } catch (std::out_of_range& e) {
50834       {
50835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50836       };
50837     } catch (std::exception& e) {
50838       {
50839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50840       };
50841     } catch (...) {
50842       {
50843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50844       };
50845     }
50846   }
50847 }
50848
50849
50850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
50851   void * jresult ;
50852   Dali::Signal< void (Dali::Actor) > *result = 0 ;
50853
50854   {
50855     try {
50856       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
50857     } catch (std::out_of_range& e) {
50858       {
50859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50860       };
50861     } catch (std::exception& e) {
50862       {
50863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50864       };
50865     } catch (...) {
50866       {
50867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50868       };
50869     }
50870   }
50871   jresult = (void *)result;
50872   return jresult;
50873 }
50874
50875
50876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
50877   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
50878
50879   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
50880   {
50881     try {
50882       delete arg1;
50883     } catch (std::out_of_range& e) {
50884       {
50885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50886       };
50887     } catch (std::exception& e) {
50888       {
50889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50890       };
50891     } catch (...) {
50892       {
50893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50894       };
50895     }
50896   }
50897 }
50898
50899
50900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
50901   unsigned int jresult ;
50902   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50903   bool result;
50904
50905   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50906   {
50907     try {
50908       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50909     } catch (std::out_of_range& e) {
50910       {
50911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50912       };
50913     } catch (std::exception& e) {
50914       {
50915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50916       };
50917     } catch (...) {
50918       {
50919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50920       };
50921     }
50922   }
50923   jresult = result;
50924   return jresult;
50925 }
50926
50927
50928 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
50929   unsigned long jresult ;
50930   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50931   std::size_t result;
50932
50933   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50934   {
50935     try {
50936       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
50937     } catch (std::out_of_range& e) {
50938       {
50939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50940       };
50941     } catch (std::exception& e) {
50942       {
50943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50944       };
50945     } catch (...) {
50946       {
50947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50948       };
50949     }
50950   }
50951   jresult = (unsigned long)result;
50952   return jresult;
50953 }
50954
50955
50956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
50957   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50958   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50959
50960   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50961   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50962   {
50963     try {
50964       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
50965     } catch (std::out_of_range& e) {
50966       {
50967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50968       };
50969     } catch (std::exception& e) {
50970       {
50971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50972       };
50973     } catch (...) {
50974       {
50975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50976       };
50977     }
50978   }
50979 }
50980
50981
50982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
50983   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
50984   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
50985
50986   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
50987   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
50988   {
50989     try {
50990       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
50991     } catch (std::out_of_range& e) {
50992       {
50993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50994       };
50995     } catch (std::exception& e) {
50996       {
50997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50998       };
50999     } catch (...) {
51000       {
51001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51002       };
51003     }
51004   }
51005 }
51006
51007
51008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
51009   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51010   Dali::KeyEvent *arg2 = 0 ;
51011
51012   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51013   arg2 = (Dali::KeyEvent *)jarg2;
51014   if (!arg2) {
51015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
51016     return ;
51017   }
51018   {
51019     try {
51020       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
51021     } catch (std::out_of_range& e) {
51022       {
51023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51024       };
51025     } catch (std::exception& e) {
51026       {
51027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51028       };
51029     } catch (...) {
51030       {
51031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51032       };
51033     }
51034   }
51035 }
51036
51037
51038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
51039   void * jresult ;
51040   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
51041
51042   {
51043     try {
51044       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
51045     } catch (std::out_of_range& e) {
51046       {
51047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51048       };
51049     } catch (std::exception& e) {
51050       {
51051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51052       };
51053     } catch (...) {
51054       {
51055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51056       };
51057     }
51058   }
51059   jresult = (void *)result;
51060   return jresult;
51061 }
51062
51063
51064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
51065   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
51066
51067   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
51068   {
51069     try {
51070       delete arg1;
51071     } catch (std::out_of_range& e) {
51072       {
51073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51074       };
51075     } catch (std::exception& e) {
51076       {
51077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51078       };
51079     } catch (...) {
51080       {
51081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51082       };
51083     }
51084   }
51085 }
51086
51087
51088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
51089   unsigned int jresult ;
51090   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51091   bool result;
51092
51093   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51094   {
51095     try {
51096       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51097     } catch (std::out_of_range& e) {
51098       {
51099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51100       };
51101     } catch (std::exception& e) {
51102       {
51103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51104       };
51105     } catch (...) {
51106       {
51107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51108       };
51109     }
51110   }
51111   jresult = result;
51112   return jresult;
51113 }
51114
51115
51116 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
51117   unsigned long jresult ;
51118   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51119   std::size_t result;
51120
51121   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51122   {
51123     try {
51124       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
51125     } catch (std::out_of_range& e) {
51126       {
51127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51128       };
51129     } catch (std::exception& e) {
51130       {
51131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51132       };
51133     } catch (...) {
51134       {
51135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51136       };
51137     }
51138   }
51139   jresult = (unsigned long)result;
51140   return jresult;
51141 }
51142
51143
51144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
51145   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51146   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51147
51148   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51149   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51150   {
51151     try {
51152       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51153     } catch (std::out_of_range& e) {
51154       {
51155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51156       };
51157     } catch (std::exception& e) {
51158       {
51159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51160       };
51161     } catch (...) {
51162       {
51163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51164       };
51165     }
51166   }
51167 }
51168
51169
51170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
51171   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51172   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
51173
51174   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51175   arg2 = (void (*)(Dali::TouchData const &))jarg2;
51176   {
51177     try {
51178       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51179     } catch (std::out_of_range& e) {
51180       {
51181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51182       };
51183     } catch (std::exception& e) {
51184       {
51185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51186       };
51187     } catch (...) {
51188       {
51189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51190       };
51191     }
51192   }
51193 }
51194
51195
51196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
51197   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51198   Dali::TouchData *arg2 = 0 ;
51199
51200   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51201   arg2 = (Dali::TouchData *)jarg2;
51202   if (!arg2) {
51203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51204     return ;
51205   }
51206   {
51207     try {
51208       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
51209     } catch (std::out_of_range& e) {
51210       {
51211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51212       };
51213     } catch (std::exception& e) {
51214       {
51215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51216       };
51217     } catch (...) {
51218       {
51219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51220       };
51221     }
51222   }
51223 }
51224
51225
51226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
51227   void * jresult ;
51228   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
51229
51230   {
51231     try {
51232       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
51233     } catch (std::out_of_range& e) {
51234       {
51235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51236       };
51237     } catch (std::exception& e) {
51238       {
51239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51240       };
51241     } catch (...) {
51242       {
51243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51244       };
51245     }
51246   }
51247   jresult = (void *)result;
51248   return jresult;
51249 }
51250
51251
51252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
51253   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
51254
51255   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
51256   {
51257     try {
51258       delete arg1;
51259     } catch (std::out_of_range& e) {
51260       {
51261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51262       };
51263     } catch (std::exception& e) {
51264       {
51265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51266       };
51267     } catch (...) {
51268       {
51269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51270       };
51271     }
51272   }
51273 }
51274
51275
51276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
51277   unsigned int jresult ;
51278   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51279   bool result;
51280
51281   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51282   {
51283     try {
51284       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51285     } catch (std::out_of_range& e) {
51286       {
51287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51288       };
51289     } catch (std::exception& e) {
51290       {
51291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51292       };
51293     } catch (...) {
51294       {
51295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51296       };
51297     }
51298   }
51299   jresult = result;
51300   return jresult;
51301 }
51302
51303
51304 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
51305   unsigned long jresult ;
51306   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51307   std::size_t result;
51308
51309   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51310   {
51311     try {
51312       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
51313     } catch (std::out_of_range& e) {
51314       {
51315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51316       };
51317     } catch (std::exception& e) {
51318       {
51319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51320       };
51321     } catch (...) {
51322       {
51323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51324       };
51325     }
51326   }
51327   jresult = (unsigned long)result;
51328   return jresult;
51329 }
51330
51331
51332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
51333   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51334   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51335
51336   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51337   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51338   {
51339     try {
51340       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51341     } catch (std::out_of_range& e) {
51342       {
51343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51344       };
51345     } catch (std::exception& e) {
51346       {
51347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51348       };
51349     } catch (...) {
51350       {
51351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51352       };
51353     }
51354   }
51355 }
51356
51357
51358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
51359   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51360   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
51361
51362   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51363   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
51364   {
51365     try {
51366       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51367     } catch (std::out_of_range& e) {
51368       {
51369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51370       };
51371     } catch (std::exception& e) {
51372       {
51373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51374       };
51375     } catch (...) {
51376       {
51377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51378       };
51379     }
51380   }
51381 }
51382
51383
51384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
51385   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51386   Dali::WheelEvent *arg2 = 0 ;
51387
51388   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51389   arg2 = (Dali::WheelEvent *)jarg2;
51390   if (!arg2) {
51391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
51392     return ;
51393   }
51394   {
51395     try {
51396       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
51397     } catch (std::out_of_range& e) {
51398       {
51399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51400       };
51401     } catch (std::exception& e) {
51402       {
51403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51404       };
51405     } catch (...) {
51406       {
51407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51408       };
51409     }
51410   }
51411 }
51412
51413
51414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
51415   void * jresult ;
51416   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
51417
51418   {
51419     try {
51420       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
51421     } catch (std::out_of_range& e) {
51422       {
51423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51424       };
51425     } catch (std::exception& e) {
51426       {
51427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51428       };
51429     } catch (...) {
51430       {
51431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51432       };
51433     }
51434   }
51435   jresult = (void *)result;
51436   return jresult;
51437 }
51438
51439
51440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
51441   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
51442
51443   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
51444   {
51445     try {
51446       delete arg1;
51447     } catch (std::out_of_range& e) {
51448       {
51449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51450       };
51451     } catch (std::exception& e) {
51452       {
51453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51454       };
51455     } catch (...) {
51456       {
51457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51458       };
51459     }
51460   }
51461 }
51462
51463
51464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
51465   void * jresult ;
51466   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51467
51468   {
51469     try {
51470       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
51471     } catch (std::out_of_range& e) {
51472       {
51473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51474       };
51475     } catch (std::exception& e) {
51476       {
51477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51478       };
51479     } catch (...) {
51480       {
51481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51482       };
51483     }
51484   }
51485   jresult = (void *)result;
51486   return jresult;
51487 }
51488
51489
51490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
51491   void * jresult ;
51492   Dali::Radian arg1 ;
51493   Dali::Radian arg2 ;
51494   Dali::Radian *argp1 ;
51495   Dali::Radian *argp2 ;
51496   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51497
51498   argp1 = (Dali::Radian *)jarg1;
51499   if (!argp1) {
51500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51501     return 0;
51502   }
51503   arg1 = *argp1;
51504   argp2 = (Dali::Radian *)jarg2;
51505   if (!argp2) {
51506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
51507     return 0;
51508   }
51509   arg2 = *argp2;
51510   {
51511     try {
51512       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
51513     } catch (std::out_of_range& e) {
51514       {
51515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51516       };
51517     } catch (std::exception& e) {
51518       {
51519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51520       };
51521     } catch (...) {
51522       {
51523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51524       };
51525     }
51526   }
51527   jresult = (void *)result;
51528   return jresult;
51529 }
51530
51531
51532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
51533   void * jresult ;
51534   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
51535   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
51536
51537   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51538   if (!arg1) {
51539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
51540     return 0;
51541   }
51542   {
51543     try {
51544       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
51545     } catch (std::out_of_range& e) {
51546       {
51547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51548       };
51549     } catch (std::exception& e) {
51550       {
51551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51552       };
51553     } catch (...) {
51554       {
51555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51556       };
51557     }
51558   }
51559   jresult = (void *)result;
51560   return jresult;
51561 }
51562
51563
51564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
51565   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51566   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51567
51568   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51569   arg2 = (Dali::Radian *)jarg2;
51570   if (arg1) (arg1)->first = *arg2;
51571 }
51572
51573
51574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
51575   void * jresult ;
51576   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51577   Dali::Radian *result = 0 ;
51578
51579   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51580   result = (Dali::Radian *)& ((arg1)->first);
51581   jresult = (void *)result;
51582   return jresult;
51583 }
51584
51585
51586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
51587   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51588   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
51589
51590   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51591   arg2 = (Dali::Radian *)jarg2;
51592   if (arg1) (arg1)->second = *arg2;
51593 }
51594
51595
51596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
51597   void * jresult ;
51598   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51599   Dali::Radian *result = 0 ;
51600
51601   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51602   result = (Dali::Radian *)& ((arg1)->second);
51603   jresult = (void *)result;
51604   return jresult;
51605 }
51606
51607
51608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
51609   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
51610
51611   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
51612   {
51613     try {
51614       delete arg1;
51615     } catch (std::out_of_range& e) {
51616       {
51617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51618       };
51619     } catch (std::exception& e) {
51620       {
51621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51622       };
51623     } catch (...) {
51624       {
51625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51626       };
51627     }
51628   }
51629 }
51630
51631
51632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
51633   unsigned int jresult ;
51634   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51635   bool result;
51636
51637   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51638   {
51639     try {
51640       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);
51641     } catch (std::out_of_range& e) {
51642       {
51643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51644       };
51645     } catch (std::exception& e) {
51646       {
51647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51648       };
51649     } catch (...) {
51650       {
51651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51652       };
51653     }
51654   }
51655   jresult = result;
51656   return jresult;
51657 }
51658
51659
51660 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51661   unsigned long jresult ;
51662   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51663   std::size_t result;
51664
51665   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51666   {
51667     try {
51668       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);
51669     } catch (std::out_of_range& e) {
51670       {
51671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51672       };
51673     } catch (std::exception& e) {
51674       {
51675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51676       };
51677     } catch (...) {
51678       {
51679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51680       };
51681     }
51682   }
51683   jresult = (unsigned long)result;
51684   return jresult;
51685 }
51686
51687
51688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51689   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51690   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51691
51692   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51693   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51694   {
51695     try {
51696       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51697     } catch (std::out_of_range& e) {
51698       {
51699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51700       };
51701     } catch (std::exception& e) {
51702       {
51703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51704       };
51705     } catch (...) {
51706       {
51707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51708       };
51709     }
51710   }
51711 }
51712
51713
51714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51715   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51716   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
51717
51718   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51719   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
51720   {
51721     try {
51722       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51723     } catch (std::out_of_range& e) {
51724       {
51725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51726       };
51727     } catch (std::exception& e) {
51728       {
51729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51730       };
51731     } catch (...) {
51732       {
51733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51734       };
51735     }
51736   }
51737 }
51738
51739
51740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51741   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51742   Dali::Actor arg2 ;
51743   Dali::PanGesture *arg3 = 0 ;
51744   Dali::Actor *argp2 ;
51745
51746   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51747   argp2 = (Dali::Actor *)jarg2;
51748   if (!argp2) {
51749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51750     return ;
51751   }
51752   arg2 = *argp2;
51753   arg3 = (Dali::PanGesture *)jarg3;
51754   if (!arg3) {
51755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
51756     return ;
51757   }
51758   {
51759     try {
51760       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
51761     } catch (std::out_of_range& e) {
51762       {
51763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51764       };
51765     } catch (std::exception& e) {
51766       {
51767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51768       };
51769     } catch (...) {
51770       {
51771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51772       };
51773     }
51774   }
51775 }
51776
51777
51778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
51779   void * jresult ;
51780   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
51781
51782   {
51783     try {
51784       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
51785     } catch (std::out_of_range& e) {
51786       {
51787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51788       };
51789     } catch (std::exception& e) {
51790       {
51791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51792       };
51793     } catch (...) {
51794       {
51795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51796       };
51797     }
51798   }
51799   jresult = (void *)result;
51800   return jresult;
51801 }
51802
51803
51804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
51805   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
51806
51807   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
51808   {
51809     try {
51810       delete arg1;
51811     } catch (std::out_of_range& e) {
51812       {
51813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51814       };
51815     } catch (std::exception& e) {
51816       {
51817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51818       };
51819     } catch (...) {
51820       {
51821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51822       };
51823     }
51824   }
51825 }
51826
51827
51828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
51829   unsigned int jresult ;
51830   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51831   bool result;
51832
51833   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51834   {
51835     try {
51836       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);
51837     } catch (std::out_of_range& e) {
51838       {
51839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51840       };
51841     } catch (std::exception& e) {
51842       {
51843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51844       };
51845     } catch (...) {
51846       {
51847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51848       };
51849     }
51850   }
51851   jresult = result;
51852   return jresult;
51853 }
51854
51855
51856 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51857   unsigned long jresult ;
51858   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51859   std::size_t result;
51860
51861   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51862   {
51863     try {
51864       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);
51865     } catch (std::out_of_range& e) {
51866       {
51867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51868       };
51869     } catch (std::exception& e) {
51870       {
51871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51872       };
51873     } catch (...) {
51874       {
51875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51876       };
51877     }
51878   }
51879   jresult = (unsigned long)result;
51880   return jresult;
51881 }
51882
51883
51884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51885   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51886   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51887
51888   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51889   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51890   {
51891     try {
51892       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51893     } catch (std::out_of_range& e) {
51894       {
51895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51896       };
51897     } catch (std::exception& e) {
51898       {
51899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51900       };
51901     } catch (...) {
51902       {
51903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51904       };
51905     }
51906   }
51907 }
51908
51909
51910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51911   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51912   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
51913
51914   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51915   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
51916   {
51917     try {
51918       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51919     } catch (std::out_of_range& e) {
51920       {
51921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51922       };
51923     } catch (std::exception& e) {
51924       {
51925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51926       };
51927     } catch (...) {
51928       {
51929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51930       };
51931     }
51932   }
51933 }
51934
51935
51936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51937   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
51938   Dali::Actor arg2 ;
51939   Dali::PinchGesture *arg3 = 0 ;
51940   Dali::Actor *argp2 ;
51941
51942   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
51943   argp2 = (Dali::Actor *)jarg2;
51944   if (!argp2) {
51945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51946     return ;
51947   }
51948   arg2 = *argp2;
51949   arg3 = (Dali::PinchGesture *)jarg3;
51950   if (!arg3) {
51951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
51952     return ;
51953   }
51954   {
51955     try {
51956       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
51957     } catch (std::out_of_range& e) {
51958       {
51959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51960       };
51961     } catch (std::exception& e) {
51962       {
51963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51964       };
51965     } catch (...) {
51966       {
51967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51968       };
51969     }
51970   }
51971 }
51972
51973
51974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
51975   void * jresult ;
51976   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
51977
51978   {
51979     try {
51980       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
51981     } catch (std::out_of_range& e) {
51982       {
51983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51984       };
51985     } catch (std::exception& e) {
51986       {
51987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51988       };
51989     } catch (...) {
51990       {
51991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51992       };
51993     }
51994   }
51995   jresult = (void *)result;
51996   return jresult;
51997 }
51998
51999
52000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
52001   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
52002
52003   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
52004   {
52005     try {
52006       delete arg1;
52007     } catch (std::out_of_range& e) {
52008       {
52009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52010       };
52011     } catch (std::exception& e) {
52012       {
52013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52014       };
52015     } catch (...) {
52016       {
52017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52018       };
52019     }
52020   }
52021 }
52022
52023
52024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
52025   unsigned int jresult ;
52026   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52027   bool result;
52028
52029   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52030   {
52031     try {
52032       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);
52033     } catch (std::out_of_range& e) {
52034       {
52035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52036       };
52037     } catch (std::exception& e) {
52038       {
52039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52040       };
52041     } catch (...) {
52042       {
52043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52044       };
52045     }
52046   }
52047   jresult = result;
52048   return jresult;
52049 }
52050
52051
52052 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
52053   unsigned long jresult ;
52054   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52055   std::size_t result;
52056
52057   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52058   {
52059     try {
52060       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);
52061     } catch (std::out_of_range& e) {
52062       {
52063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52064       };
52065     } catch (std::exception& e) {
52066       {
52067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52068       };
52069     } catch (...) {
52070       {
52071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52072       };
52073     }
52074   }
52075   jresult = (unsigned long)result;
52076   return jresult;
52077 }
52078
52079
52080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
52081   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52082   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52083
52084   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52085   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52086   {
52087     try {
52088       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52089     } catch (std::out_of_range& e) {
52090       {
52091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52092       };
52093     } catch (std::exception& e) {
52094       {
52095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52096       };
52097     } catch (...) {
52098       {
52099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52100       };
52101     }
52102   }
52103 }
52104
52105
52106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
52107   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52108   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
52109
52110   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52111   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
52112   {
52113     try {
52114       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52115     } catch (std::out_of_range& e) {
52116       {
52117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52118       };
52119     } catch (std::exception& e) {
52120       {
52121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52122       };
52123     } catch (...) {
52124       {
52125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52126       };
52127     }
52128   }
52129 }
52130
52131
52132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52133   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52134   Dali::Actor arg2 ;
52135   Dali::TapGesture *arg3 = 0 ;
52136   Dali::Actor *argp2 ;
52137
52138   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52139   argp2 = (Dali::Actor *)jarg2;
52140   if (!argp2) {
52141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52142     return ;
52143   }
52144   arg2 = *argp2;
52145   arg3 = (Dali::TapGesture *)jarg3;
52146   if (!arg3) {
52147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
52148     return ;
52149   }
52150   {
52151     try {
52152       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
52153     } catch (std::out_of_range& e) {
52154       {
52155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52156       };
52157     } catch (std::exception& e) {
52158       {
52159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52160       };
52161     } catch (...) {
52162       {
52163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52164       };
52165     }
52166   }
52167 }
52168
52169
52170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
52171   void * jresult ;
52172   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
52173
52174   {
52175     try {
52176       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
52177     } catch (std::out_of_range& e) {
52178       {
52179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52180       };
52181     } catch (std::exception& e) {
52182       {
52183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52184       };
52185     } catch (...) {
52186       {
52187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52188       };
52189     }
52190   }
52191   jresult = (void *)result;
52192   return jresult;
52193 }
52194
52195
52196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
52197   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
52198
52199   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
52200   {
52201     try {
52202       delete arg1;
52203     } catch (std::out_of_range& e) {
52204       {
52205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52206       };
52207     } catch (std::exception& e) {
52208       {
52209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52210       };
52211     } catch (...) {
52212       {
52213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52214       };
52215     }
52216   }
52217 }
52218
52219
52220 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AnimationSignal_Empty(void * jarg1) {
52221   unsigned int jresult ;
52222   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52223   bool result;
52224
52225   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52226   {
52227     try {
52228       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52229     } catch (std::out_of_range& e) {
52230       {
52231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52232       };
52233     } catch (std::exception& e) {
52234       {
52235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52236       };
52237     } catch (...) {
52238       {
52239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52240       };
52241     }
52242   }
52243   jresult = result;
52244   return jresult;
52245 }
52246
52247
52248 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AnimationSignal_GetConnectionCount(void * jarg1) {
52249   unsigned long jresult ;
52250   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52251   std::size_t result;
52252
52253   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52254   {
52255     try {
52256       result = Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Animation &) > const *)arg1);
52257     } catch (std::out_of_range& e) {
52258       {
52259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52260       };
52261     } catch (std::exception& e) {
52262       {
52263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52264       };
52265     } catch (...) {
52266       {
52267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52268       };
52269     }
52270   }
52271   jresult = (unsigned long)result;
52272   return jresult;
52273 }
52274
52275
52276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Connect(void * jarg1, void * jarg2) {
52277   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52278   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52279
52280   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52281   arg2 = (void (*)(Dali::Animation &))jarg2;
52282   {
52283     try {
52284       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Connect(arg1,arg2);
52285     } catch (std::out_of_range& e) {
52286       {
52287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52288       };
52289     } catch (std::exception& e) {
52290       {
52291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52292       };
52293     } catch (...) {
52294       {
52295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52296       };
52297     }
52298   }
52299 }
52300
52301
52302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Disconnect(void * jarg1, void * jarg2) {
52303   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52304   void (*arg2)(Dali::Animation &) = (void (*)(Dali::Animation &)) 0 ;
52305
52306   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52307   arg2 = (void (*)(Dali::Animation &))jarg2;
52308   {
52309     try {
52310       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Disconnect(arg1,arg2);
52311     } catch (std::out_of_range& e) {
52312       {
52313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52314       };
52315     } catch (std::exception& e) {
52316       {
52317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52318       };
52319     } catch (...) {
52320       {
52321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52322       };
52323     }
52324   }
52325 }
52326
52327
52328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AnimationSignal_Emit(void * jarg1, void * jarg2) {
52329   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52330   Dali::Animation *arg2 = 0 ;
52331
52332   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52333   arg2 = (Dali::Animation *)jarg2;
52334   if (!arg2) {
52335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
52336     return ;
52337   }
52338   {
52339     try {
52340       Dali_Signal_Sl_void_Sp_Dali_Animation_SA__SP__Sg__Emit(arg1,*arg2);
52341     } catch (std::out_of_range& e) {
52342       {
52343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52344       };
52345     } catch (std::exception& e) {
52346       {
52347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52348       };
52349     } catch (...) {
52350       {
52351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52352       };
52353     }
52354   }
52355 }
52356
52357
52358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimationSignal() {
52359   void * jresult ;
52360   Dali::Signal< void (Dali::Animation &) > *result = 0 ;
52361
52362   {
52363     try {
52364       result = (Dali::Signal< void (Dali::Animation &) > *)new Dali::Signal< void (Dali::Animation &) >();
52365     } catch (std::out_of_range& e) {
52366       {
52367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52368       };
52369     } catch (std::exception& e) {
52370       {
52371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52372       };
52373     } catch (...) {
52374       {
52375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52376       };
52377     }
52378   }
52379   jresult = (void *)result;
52380   return jresult;
52381 }
52382
52383
52384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimationSignal(void * jarg1) {
52385   Dali::Signal< void (Dali::Animation &) > *arg1 = (Dali::Signal< void (Dali::Animation &) > *) 0 ;
52386
52387   arg1 = (Dali::Signal< void (Dali::Animation &) > *)jarg1;
52388   {
52389     try {
52390       delete arg1;
52391     } catch (std::out_of_range& e) {
52392       {
52393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52394       };
52395     } catch (std::exception& e) {
52396       {
52397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52398       };
52399     } catch (...) {
52400       {
52401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52402       };
52403     }
52404   }
52405 }
52406
52407
52408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
52409   unsigned int jresult ;
52410   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52411   bool result;
52412
52413   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52414   {
52415     try {
52416       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52417     } catch (std::out_of_range& e) {
52418       {
52419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52420       };
52421     } catch (std::exception& e) {
52422       {
52423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52424       };
52425     } catch (...) {
52426       {
52427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52428       };
52429     }
52430   }
52431   jresult = result;
52432   return jresult;
52433 }
52434
52435
52436 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
52437   unsigned long jresult ;
52438   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52439   std::size_t result;
52440
52441   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52442   {
52443     try {
52444       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
52445     } catch (std::out_of_range& e) {
52446       {
52447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52448       };
52449     } catch (std::exception& e) {
52450       {
52451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52452       };
52453     } catch (...) {
52454       {
52455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52456       };
52457     }
52458   }
52459   jresult = (unsigned long)result;
52460   return jresult;
52461 }
52462
52463
52464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
52465   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52466   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52467
52468   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52469   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52470   {
52471     try {
52472       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
52473     } catch (std::out_of_range& e) {
52474       {
52475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52476       };
52477     } catch (std::exception& e) {
52478       {
52479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52480       };
52481     } catch (...) {
52482       {
52483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52484       };
52485     }
52486   }
52487 }
52488
52489
52490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
52491   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52492   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
52493
52494   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52495   arg2 = (void (*)(Dali::ResourceImage))jarg2;
52496   {
52497     try {
52498       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
52499     } catch (std::out_of_range& e) {
52500       {
52501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52502       };
52503     } catch (std::exception& e) {
52504       {
52505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52506       };
52507     } catch (...) {
52508       {
52509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52510       };
52511     }
52512   }
52513 }
52514
52515
52516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
52517   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52518   Dali::ResourceImage arg2 ;
52519   Dali::ResourceImage *argp2 ;
52520
52521   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52522   argp2 = (Dali::ResourceImage *)jarg2;
52523   if (!argp2) {
52524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
52525     return ;
52526   }
52527   arg2 = *argp2;
52528   {
52529     try {
52530       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
52531     } catch (std::out_of_range& e) {
52532       {
52533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52534       };
52535     } catch (std::exception& e) {
52536       {
52537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52538       };
52539     } catch (...) {
52540       {
52541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52542       };
52543     }
52544   }
52545 }
52546
52547
52548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
52549   void * jresult ;
52550   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
52551
52552   {
52553     try {
52554       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
52555     } catch (std::out_of_range& e) {
52556       {
52557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52558       };
52559     } catch (std::exception& e) {
52560       {
52561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52562       };
52563     } catch (...) {
52564       {
52565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52566       };
52567     }
52568   }
52569   jresult = (void *)result;
52570   return jresult;
52571 }
52572
52573
52574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
52575   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
52576
52577   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
52578   {
52579     try {
52580       delete arg1;
52581     } catch (std::out_of_range& e) {
52582       {
52583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52584       };
52585     } catch (std::exception& e) {
52586       {
52587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52588       };
52589     } catch (...) {
52590       {
52591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52592       };
52593     }
52594   }
52595 }
52596
52597
52598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
52599   void * jresult ;
52600   Dali::Timer *result = 0 ;
52601
52602   {
52603     try {
52604       result = (Dali::Timer *)new Dali::Timer();
52605     } catch (std::out_of_range& e) {
52606       {
52607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52608       };
52609     } catch (std::exception& e) {
52610       {
52611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52612       };
52613     } catch (...) {
52614       {
52615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52616       };
52617     }
52618   }
52619   jresult = (void *)result;
52620   return jresult;
52621 }
52622
52623
52624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
52625   void * jresult ;
52626   unsigned int arg1 ;
52627   Dali::Timer result;
52628
52629   arg1 = (unsigned int)jarg1;
52630   {
52631     try {
52632       result = Dali::Timer::New(arg1);
52633     } catch (std::out_of_range& e) {
52634       {
52635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52636       };
52637     } catch (std::exception& e) {
52638       {
52639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52640       };
52641     } catch (...) {
52642       {
52643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52644       };
52645     }
52646   }
52647   jresult = new Dali::Timer((const Dali::Timer &)result);
52648   return jresult;
52649 }
52650
52651
52652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
52653   void * jresult ;
52654   Dali::Timer *arg1 = 0 ;
52655   Dali::Timer *result = 0 ;
52656
52657   arg1 = (Dali::Timer *)jarg1;
52658   if (!arg1) {
52659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52660     return 0;
52661   }
52662   {
52663     try {
52664       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
52665     } catch (std::out_of_range& e) {
52666       {
52667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52668       };
52669     } catch (std::exception& e) {
52670       {
52671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52672       };
52673     } catch (...) {
52674       {
52675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52676       };
52677     }
52678   }
52679   jresult = (void *)result;
52680   return jresult;
52681 }
52682
52683
52684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
52685   void * jresult ;
52686   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52687   Dali::Timer *arg2 = 0 ;
52688   Dali::Timer *result = 0 ;
52689
52690   arg1 = (Dali::Timer *)jarg1;
52691   arg2 = (Dali::Timer *)jarg2;
52692   if (!arg2) {
52693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
52694     return 0;
52695   }
52696   {
52697     try {
52698       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
52699     } catch (std::out_of_range& e) {
52700       {
52701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52702       };
52703     } catch (std::exception& e) {
52704       {
52705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52706       };
52707     } catch (...) {
52708       {
52709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52710       };
52711     }
52712   }
52713   jresult = (void *)result;
52714   return jresult;
52715 }
52716
52717
52718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
52719   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52720
52721   arg1 = (Dali::Timer *)jarg1;
52722   {
52723     try {
52724       delete arg1;
52725     } catch (std::out_of_range& e) {
52726       {
52727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52728       };
52729     } catch (std::exception& e) {
52730       {
52731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52732       };
52733     } catch (...) {
52734       {
52735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52736       };
52737     }
52738   }
52739 }
52740
52741
52742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
52743   void * jresult ;
52744   Dali::BaseHandle arg1 ;
52745   Dali::BaseHandle *argp1 ;
52746   Dali::Timer result;
52747
52748   argp1 = (Dali::BaseHandle *)jarg1;
52749   if (!argp1) {
52750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52751     return 0;
52752   }
52753   arg1 = *argp1;
52754   {
52755     try {
52756       result = Dali::Timer::DownCast(arg1);
52757     } catch (std::out_of_range& e) {
52758       {
52759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52760       };
52761     } catch (std::exception& e) {
52762       {
52763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52764       };
52765     } catch (...) {
52766       {
52767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52768       };
52769     }
52770   }
52771   jresult = new Dali::Timer((const Dali::Timer &)result);
52772   return jresult;
52773 }
52774
52775
52776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
52777   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52778
52779   arg1 = (Dali::Timer *)jarg1;
52780   {
52781     try {
52782       (arg1)->Start();
52783     } catch (std::out_of_range& e) {
52784       {
52785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52786       };
52787     } catch (std::exception& e) {
52788       {
52789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52790       };
52791     } catch (...) {
52792       {
52793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52794       };
52795     }
52796   }
52797 }
52798
52799
52800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
52801   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52802
52803   arg1 = (Dali::Timer *)jarg1;
52804   {
52805     try {
52806       (arg1)->Stop();
52807     } catch (std::out_of_range& e) {
52808       {
52809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52810       };
52811     } catch (std::exception& e) {
52812       {
52813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52814       };
52815     } catch (...) {
52816       {
52817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52818       };
52819     }
52820   }
52821 }
52822
52823
52824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
52825   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52826   unsigned int arg2 ;
52827
52828   arg1 = (Dali::Timer *)jarg1;
52829   arg2 = (unsigned int)jarg2;
52830   {
52831     try {
52832       (arg1)->SetInterval(arg2);
52833     } catch (std::out_of_range& e) {
52834       {
52835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52836       };
52837     } catch (std::exception& e) {
52838       {
52839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52840       };
52841     } catch (...) {
52842       {
52843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52844       };
52845     }
52846   }
52847 }
52848
52849
52850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
52851   unsigned int jresult ;
52852   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52853   unsigned int result;
52854
52855   arg1 = (Dali::Timer *)jarg1;
52856   {
52857     try {
52858       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
52859     } catch (std::out_of_range& e) {
52860       {
52861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52862       };
52863     } catch (std::exception& e) {
52864       {
52865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52866       };
52867     } catch (...) {
52868       {
52869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52870       };
52871     }
52872   }
52873   jresult = result;
52874   return jresult;
52875 }
52876
52877
52878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
52879   unsigned int jresult ;
52880   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52881   bool result;
52882
52883   arg1 = (Dali::Timer *)jarg1;
52884   {
52885     try {
52886       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
52887     } catch (std::out_of_range& e) {
52888       {
52889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52890       };
52891     } catch (std::exception& e) {
52892       {
52893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52894       };
52895     } catch (...) {
52896       {
52897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52898       };
52899     }
52900   }
52901   jresult = result;
52902   return jresult;
52903 }
52904
52905
52906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
52907   void * jresult ;
52908   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
52909   Dali::Timer::TimerSignalType *result = 0 ;
52910
52911   arg1 = (Dali::Timer *)jarg1;
52912   {
52913     try {
52914       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
52915     } catch (std::out_of_range& e) {
52916       {
52917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52918       };
52919     } catch (std::exception& e) {
52920       {
52921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52922       };
52923     } catch (...) {
52924       {
52925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52926       };
52927     }
52928   }
52929   jresult = (void *)result;
52930   return jresult;
52931 }
52932
52933
52934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
52935   void * jresult ;
52936   Dali::DragAndDropDetector *result = 0 ;
52937
52938   {
52939     try {
52940       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
52941     } catch (std::out_of_range& e) {
52942       {
52943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52944       };
52945     } catch (std::exception& e) {
52946       {
52947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52948       };
52949     } catch (...) {
52950       {
52951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52952       };
52953     }
52954   }
52955   jresult = (void *)result;
52956   return jresult;
52957 }
52958
52959
52960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
52961   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52962
52963   arg1 = (Dali::DragAndDropDetector *)jarg1;
52964   {
52965     try {
52966       delete arg1;
52967     } catch (std::out_of_range& e) {
52968       {
52969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52970       };
52971     } catch (std::exception& e) {
52972       {
52973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52974       };
52975     } catch (...) {
52976       {
52977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52978       };
52979     }
52980   }
52981 }
52982
52983
52984 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
52985   char * jresult ;
52986   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
52987   std::string *result = 0 ;
52988
52989   arg1 = (Dali::DragAndDropDetector *)jarg1;
52990   {
52991     try {
52992       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
52993     } catch (std::out_of_range& e) {
52994       {
52995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52996       };
52997     } catch (std::exception& e) {
52998       {
52999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53000       };
53001     } catch (...) {
53002       {
53003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53004       };
53005     }
53006   }
53007   jresult = SWIG_csharp_string_callback(result->c_str());
53008   return jresult;
53009 }
53010
53011
53012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
53013   void * jresult ;
53014   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53015   Dali::Vector2 result;
53016
53017   arg1 = (Dali::DragAndDropDetector *)jarg1;
53018   {
53019     try {
53020       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
53021     } catch (std::out_of_range& e) {
53022       {
53023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53024       };
53025     } catch (std::exception& e) {
53026       {
53027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53028       };
53029     } catch (...) {
53030       {
53031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53032       };
53033     }
53034   }
53035   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
53036   return jresult;
53037 }
53038
53039
53040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
53041   void * jresult ;
53042   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53043   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53044
53045   arg1 = (Dali::DragAndDropDetector *)jarg1;
53046   {
53047     try {
53048       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
53049     } catch (std::out_of_range& e) {
53050       {
53051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53052       };
53053     } catch (std::exception& e) {
53054       {
53055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53056       };
53057     } catch (...) {
53058       {
53059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53060       };
53061     }
53062   }
53063   jresult = (void *)result;
53064   return jresult;
53065 }
53066
53067
53068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
53069   void * jresult ;
53070   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53071   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53072
53073   arg1 = (Dali::DragAndDropDetector *)jarg1;
53074   {
53075     try {
53076       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
53077     } catch (std::out_of_range& e) {
53078       {
53079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53080       };
53081     } catch (std::exception& e) {
53082       {
53083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53084       };
53085     } catch (...) {
53086       {
53087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53088       };
53089     }
53090   }
53091   jresult = (void *)result;
53092   return jresult;
53093 }
53094
53095
53096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
53097   void * jresult ;
53098   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53099   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53100
53101   arg1 = (Dali::DragAndDropDetector *)jarg1;
53102   {
53103     try {
53104       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
53105     } catch (std::out_of_range& e) {
53106       {
53107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53108       };
53109     } catch (std::exception& e) {
53110       {
53111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53112       };
53113     } catch (...) {
53114       {
53115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53116       };
53117     }
53118   }
53119   jresult = (void *)result;
53120   return jresult;
53121 }
53122
53123
53124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
53125   void * jresult ;
53126   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
53127   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
53128
53129   arg1 = (Dali::DragAndDropDetector *)jarg1;
53130   {
53131     try {
53132       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
53133     } catch (std::out_of_range& e) {
53134       {
53135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53136       };
53137     } catch (std::exception& e) {
53138       {
53139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53140       };
53141     } catch (...) {
53142       {
53143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53144       };
53145     }
53146   }
53147   jresult = (void *)result;
53148   return jresult;
53149 }
53150
53151
53152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
53153   void * jresult ;
53154   Dali::ApplicationExtensions *result = 0 ;
53155
53156   {
53157     try {
53158       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
53159     } catch (std::out_of_range& e) {
53160       {
53161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53162       };
53163     } catch (std::exception& e) {
53164       {
53165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53166       };
53167     } catch (...) {
53168       {
53169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53170       };
53171     }
53172   }
53173   jresult = (void *)result;
53174   return jresult;
53175 }
53176
53177
53178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
53179   void * jresult ;
53180   Dali::Application *arg1 = (Dali::Application *) 0 ;
53181   Dali::ApplicationExtensions *result = 0 ;
53182
53183   arg1 = (Dali::Application *)jarg1;
53184   {
53185     try {
53186       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
53187     } catch (std::out_of_range& e) {
53188       {
53189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53190       };
53191     } catch (std::exception& e) {
53192       {
53193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53194       };
53195     } catch (...) {
53196       {
53197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53198       };
53199     }
53200   }
53201   jresult = (void *)result;
53202   return jresult;
53203 }
53204
53205
53206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
53207   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53208
53209   arg1 = (Dali::ApplicationExtensions *)jarg1;
53210   {
53211     try {
53212       delete arg1;
53213     } catch (std::out_of_range& e) {
53214       {
53215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53216       };
53217     } catch (std::exception& e) {
53218       {
53219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53220       };
53221     } catch (...) {
53222       {
53223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53224       };
53225     }
53226   }
53227 }
53228
53229
53230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
53231   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53232
53233   arg1 = (Dali::ApplicationExtensions *)jarg1;
53234   {
53235     try {
53236       (arg1)->Init();
53237     } catch (std::out_of_range& e) {
53238       {
53239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53240       };
53241     } catch (std::exception& e) {
53242       {
53243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53244       };
53245     } catch (...) {
53246       {
53247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53248       };
53249     }
53250   }
53251 }
53252
53253
53254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
53255   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53256
53257   arg1 = (Dali::ApplicationExtensions *)jarg1;
53258   {
53259     try {
53260       (arg1)->Terminate();
53261     } catch (std::out_of_range& e) {
53262       {
53263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53264       };
53265     } catch (std::exception& e) {
53266       {
53267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53268       };
53269     } catch (...) {
53270       {
53271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53272       };
53273     }
53274   }
53275 }
53276
53277
53278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
53279   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53280
53281   arg1 = (Dali::ApplicationExtensions *)jarg1;
53282   {
53283     try {
53284       (arg1)->Pause();
53285     } catch (std::out_of_range& e) {
53286       {
53287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53288       };
53289     } catch (std::exception& e) {
53290       {
53291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53292       };
53293     } catch (...) {
53294       {
53295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53296       };
53297     }
53298   }
53299 }
53300
53301
53302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
53303   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53304
53305   arg1 = (Dali::ApplicationExtensions *)jarg1;
53306   {
53307     try {
53308       (arg1)->Resume();
53309     } catch (std::out_of_range& e) {
53310       {
53311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53312       };
53313     } catch (std::exception& e) {
53314       {
53315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53316       };
53317     } catch (...) {
53318       {
53319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53320       };
53321     }
53322   }
53323 }
53324
53325
53326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
53327   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
53328
53329   arg1 = (Dali::ApplicationExtensions *)jarg1;
53330   {
53331     try {
53332       (arg1)->LanguageChange();
53333     } catch (std::out_of_range& e) {
53334       {
53335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53336       };
53337     } catch (std::exception& e) {
53338       {
53339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53340       };
53341     } catch (...) {
53342       {
53343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53344       };
53345     }
53346   }
53347 }
53348
53349
53350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3) {
53351   void * jresult ;
53352   Dali::PositionSize arg1 ;
53353   std::string *arg2 = 0 ;
53354   bool arg3 ;
53355   Dali::PositionSize *argp1 ;
53356   Dali::Window result;
53357
53358   argp1 = (Dali::PositionSize *)jarg1;
53359   if (!argp1) {
53360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53361     return 0;
53362   }
53363   arg1 = *argp1;
53364   if (!jarg2) {
53365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53366     return 0;
53367   }
53368   std::string arg2_str(jarg2);
53369   arg2 = &arg2_str;
53370   arg3 = jarg3 ? true : false;
53371   {
53372     try {
53373       result = Dali::Window::New(arg1,(std::string const &)*arg2,arg3);
53374     } catch (std::out_of_range& e) {
53375       {
53376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53377       };
53378     } catch (std::exception& e) {
53379       {
53380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53381       };
53382     } catch (...) {
53383       {
53384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53385       };
53386     }
53387   }
53388   jresult = new Dali::Window((const Dali::Window &)result);
53389
53390   //argout typemap for const std::string&
53391
53392   return jresult;
53393 }
53394
53395
53396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_1(void * jarg1, char * jarg2) {
53397   void * jresult ;
53398   Dali::PositionSize arg1 ;
53399   std::string *arg2 = 0 ;
53400   Dali::PositionSize *argp1 ;
53401   Dali::Window result;
53402
53403   argp1 = (Dali::PositionSize *)jarg1;
53404   if (!argp1) {
53405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53406     return 0;
53407   }
53408   arg1 = *argp1;
53409   if (!jarg2) {
53410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53411     return 0;
53412   }
53413   std::string arg2_str(jarg2);
53414   arg2 = &arg2_str;
53415   {
53416     try {
53417       result = Dali::Window::New(arg1,(std::string const &)*arg2);
53418     } catch (std::out_of_range& e) {
53419       {
53420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53421       };
53422     } catch (std::exception& e) {
53423       {
53424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53425       };
53426     } catch (...) {
53427       {
53428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53429       };
53430     }
53431   }
53432   jresult = new Dali::Window((const Dali::Window &)result);
53433
53434   //argout typemap for const std::string&
53435
53436   return jresult;
53437 }
53438
53439
53440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_2(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
53441   void * jresult ;
53442   Dali::PositionSize arg1 ;
53443   std::string *arg2 = 0 ;
53444   std::string *arg3 = 0 ;
53445   bool arg4 ;
53446   Dali::PositionSize *argp1 ;
53447   Dali::Window result;
53448
53449   argp1 = (Dali::PositionSize *)jarg1;
53450   if (!argp1) {
53451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53452     return 0;
53453   }
53454   arg1 = *argp1;
53455   if (!jarg2) {
53456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53457     return 0;
53458   }
53459   std::string arg2_str(jarg2);
53460   arg2 = &arg2_str;
53461   if (!jarg3) {
53462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53463     return 0;
53464   }
53465   std::string arg3_str(jarg3);
53466   arg3 = &arg3_str;
53467   arg4 = jarg4 ? true : false;
53468   {
53469     try {
53470       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
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 = new Dali::Window((const Dali::Window &)result);
53486
53487   //argout typemap for const std::string&
53488
53489
53490   //argout typemap for const std::string&
53491
53492   return jresult;
53493 }
53494
53495
53496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_New__SWIG_3(void * jarg1, char * jarg2, char * jarg3) {
53497   void * jresult ;
53498   Dali::PositionSize arg1 ;
53499   std::string *arg2 = 0 ;
53500   std::string *arg3 = 0 ;
53501   Dali::PositionSize *argp1 ;
53502   Dali::Window result;
53503
53504   argp1 = (Dali::PositionSize *)jarg1;
53505   if (!argp1) {
53506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
53507     return 0;
53508   }
53509   arg1 = *argp1;
53510   if (!jarg2) {
53511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53512     return 0;
53513   }
53514   std::string arg2_str(jarg2);
53515   arg2 = &arg2_str;
53516   if (!jarg3) {
53517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53518     return 0;
53519   }
53520   std::string arg3_str(jarg3);
53521   arg3 = &arg3_str;
53522   {
53523     try {
53524       result = Dali::Window::New(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
53525     } catch (std::out_of_range& e) {
53526       {
53527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53528       };
53529     } catch (std::exception& e) {
53530       {
53531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53532       };
53533     } catch (...) {
53534       {
53535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53536       };
53537     }
53538   }
53539   jresult = new Dali::Window((const Dali::Window &)result);
53540
53541   //argout typemap for const std::string&
53542
53543
53544   //argout typemap for const std::string&
53545
53546   return jresult;
53547 }
53548
53549
53550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_0() {
53551   void * jresult ;
53552   Dali::Window *result = 0 ;
53553
53554   {
53555     try {
53556       result = (Dali::Window *)new Dali::Window();
53557     } catch (std::out_of_range& e) {
53558       {
53559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53560       };
53561     } catch (std::exception& e) {
53562       {
53563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53564       };
53565     } catch (...) {
53566       {
53567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53568       };
53569     }
53570   }
53571   jresult = (void *)result;
53572   return jresult;
53573 }
53574
53575
53576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Window(void * jarg1) {
53577   Dali::Window *arg1 = (Dali::Window *) 0 ;
53578
53579   arg1 = (Dali::Window *)jarg1;
53580   {
53581     try {
53582       delete arg1;
53583     } catch (std::out_of_range& e) {
53584       {
53585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53586       };
53587     } catch (std::exception& e) {
53588       {
53589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53590       };
53591     } catch (...) {
53592       {
53593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53594       };
53595     }
53596   }
53597 }
53598
53599
53600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Window__SWIG_1(void * jarg1) {
53601   void * jresult ;
53602   Dali::Window *arg1 = 0 ;
53603   Dali::Window *result = 0 ;
53604
53605   arg1 = (Dali::Window *)jarg1;
53606   if (!arg1) {
53607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53608     return 0;
53609   }
53610   {
53611     try {
53612       result = (Dali::Window *)new Dali::Window((Dali::Window const &)*arg1);
53613     } catch (std::out_of_range& e) {
53614       {
53615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53616       };
53617     } catch (std::exception& e) {
53618       {
53619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53620       };
53621     } catch (...) {
53622       {
53623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53624       };
53625     }
53626   }
53627   jresult = (void *)result;
53628   return jresult;
53629 }
53630
53631
53632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_Assign(void * jarg1, void * jarg2) {
53633   void * jresult ;
53634   Dali::Window *arg1 = (Dali::Window *) 0 ;
53635   Dali::Window *arg2 = 0 ;
53636   Dali::Window *result = 0 ;
53637
53638   arg1 = (Dali::Window *)jarg1;
53639   arg2 = (Dali::Window *)jarg2;
53640   if (!arg2) {
53641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Window const & type is null", 0);
53642     return 0;
53643   }
53644   {
53645     try {
53646       result = (Dali::Window *) &(arg1)->operator =((Dali::Window const &)*arg2);
53647     } catch (std::out_of_range& e) {
53648       {
53649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53650       };
53651     } catch (std::exception& e) {
53652       {
53653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53654       };
53655     } catch (...) {
53656       {
53657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53658       };
53659     }
53660   }
53661   jresult = (void *)result;
53662   return jresult;
53663 }
53664
53665
53666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_ShowIndicator(void * jarg1, int jarg2) {
53667   Dali::Window *arg1 = (Dali::Window *) 0 ;
53668   Dali::Window::IndicatorVisibleMode arg2 ;
53669
53670   arg1 = (Dali::Window *)jarg1;
53671   arg2 = (Dali::Window::IndicatorVisibleMode)jarg2;
53672   {
53673     try {
53674       (arg1)->ShowIndicator(arg2);
53675     } catch (std::out_of_range& e) {
53676       {
53677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53678       };
53679     } catch (std::exception& e) {
53680       {
53681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53682       };
53683     } catch (...) {
53684       {
53685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53686       };
53687     }
53688   }
53689 }
53690
53691
53692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetIndicatorBgOpacity(void * jarg1, int jarg2) {
53693   Dali::Window *arg1 = (Dali::Window *) 0 ;
53694   Dali::Window::IndicatorBgOpacity arg2 ;
53695
53696   arg1 = (Dali::Window *)jarg1;
53697   arg2 = (Dali::Window::IndicatorBgOpacity)jarg2;
53698   {
53699     try {
53700       (arg1)->SetIndicatorBgOpacity(arg2);
53701     } catch (std::out_of_range& e) {
53702       {
53703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53704       };
53705     } catch (std::exception& e) {
53706       {
53707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53708       };
53709     } catch (...) {
53710       {
53711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53712       };
53713     }
53714   }
53715 }
53716
53717
53718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RotateIndicator(void * jarg1, int jarg2) {
53719   Dali::Window *arg1 = (Dali::Window *) 0 ;
53720   Dali::Window::WindowOrientation arg2 ;
53721
53722   arg1 = (Dali::Window *)jarg1;
53723   arg2 = (Dali::Window::WindowOrientation)jarg2;
53724   {
53725     try {
53726       (arg1)->RotateIndicator(arg2);
53727     } catch (std::out_of_range& e) {
53728       {
53729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53730       };
53731     } catch (std::exception& e) {
53732       {
53733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53734       };
53735     } catch (...) {
53736       {
53737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53738       };
53739     }
53740   }
53741 }
53742
53743
53744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetClass(void * jarg1, char * jarg2, char * jarg3) {
53745   Dali::Window *arg1 = (Dali::Window *) 0 ;
53746   std::string arg2 ;
53747   std::string arg3 ;
53748
53749   arg1 = (Dali::Window *)jarg1;
53750   if (!jarg2) {
53751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53752     return ;
53753   }
53754   (&arg2)->assign(jarg2);
53755   if (!jarg3) {
53756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
53757     return ;
53758   }
53759   (&arg3)->assign(jarg3);
53760   {
53761     try {
53762       (arg1)->SetClass(arg2,arg3);
53763     } catch (std::out_of_range& e) {
53764       {
53765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53766       };
53767     } catch (std::exception& e) {
53768       {
53769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53770       };
53771     } catch (...) {
53772       {
53773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53774       };
53775     }
53776   }
53777 }
53778
53779
53780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Raise(void * jarg1) {
53781   Dali::Window *arg1 = (Dali::Window *) 0 ;
53782
53783   arg1 = (Dali::Window *)jarg1;
53784   {
53785     try {
53786       (arg1)->Raise();
53787     } catch (std::out_of_range& e) {
53788       {
53789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53790       };
53791     } catch (std::exception& e) {
53792       {
53793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53794       };
53795     } catch (...) {
53796       {
53797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53798       };
53799     }
53800   }
53801 }
53802
53803
53804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Lower(void * jarg1) {
53805   Dali::Window *arg1 = (Dali::Window *) 0 ;
53806
53807   arg1 = (Dali::Window *)jarg1;
53808   {
53809     try {
53810       (arg1)->Lower();
53811     } catch (std::out_of_range& e) {
53812       {
53813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53814       };
53815     } catch (std::exception& e) {
53816       {
53817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53818       };
53819     } catch (...) {
53820       {
53821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53822       };
53823     }
53824   }
53825 }
53826
53827
53828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_Activate(void * jarg1) {
53829   Dali::Window *arg1 = (Dali::Window *) 0 ;
53830
53831   arg1 = (Dali::Window *)jarg1;
53832   {
53833     try {
53834       (arg1)->Activate();
53835     } catch (std::out_of_range& e) {
53836       {
53837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53838       };
53839     } catch (std::exception& e) {
53840       {
53841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53842       };
53843     } catch (...) {
53844       {
53845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53846       };
53847     }
53848   }
53849 }
53850
53851
53852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_AddAvailableOrientation(void * jarg1, int jarg2) {
53853   Dali::Window *arg1 = (Dali::Window *) 0 ;
53854   Dali::Window::WindowOrientation arg2 ;
53855
53856   arg1 = (Dali::Window *)jarg1;
53857   arg2 = (Dali::Window::WindowOrientation)jarg2;
53858   {
53859     try {
53860       (arg1)->AddAvailableOrientation(arg2);
53861     } catch (std::out_of_range& e) {
53862       {
53863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53864       };
53865     } catch (std::exception& e) {
53866       {
53867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53868       };
53869     } catch (...) {
53870       {
53871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53872       };
53873     }
53874   }
53875 }
53876
53877
53878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_RemoveAvailableOrientation(void * jarg1, int jarg2) {
53879   Dali::Window *arg1 = (Dali::Window *) 0 ;
53880   Dali::Window::WindowOrientation arg2 ;
53881
53882   arg1 = (Dali::Window *)jarg1;
53883   arg2 = (Dali::Window::WindowOrientation)jarg2;
53884   {
53885     try {
53886       (arg1)->RemoveAvailableOrientation(arg2);
53887     } catch (std::out_of_range& e) {
53888       {
53889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53890       };
53891     } catch (std::exception& e) {
53892       {
53893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53894       };
53895     } catch (...) {
53896       {
53897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53898       };
53899     }
53900   }
53901 }
53902
53903
53904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Window_SetPreferredOrientation(void * jarg1, int jarg2) {
53905   Dali::Window *arg1 = (Dali::Window *) 0 ;
53906   Dali::Window::WindowOrientation arg2 ;
53907
53908   arg1 = (Dali::Window *)jarg1;
53909   arg2 = (Dali::Window::WindowOrientation)jarg2;
53910   {
53911     try {
53912       (arg1)->SetPreferredOrientation(arg2);
53913     } catch (std::out_of_range& e) {
53914       {
53915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53916       };
53917     } catch (std::exception& e) {
53918       {
53919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53920       };
53921     } catch (...) {
53922       {
53923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53924       };
53925     }
53926   }
53927 }
53928
53929
53930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Window_GetPreferredOrientation(void * jarg1) {
53931   int jresult ;
53932   Dali::Window *arg1 = (Dali::Window *) 0 ;
53933   Dali::Window::WindowOrientation result;
53934
53935   arg1 = (Dali::Window *)jarg1;
53936   {
53937     try {
53938       result = (Dali::Window::WindowOrientation)(arg1)->GetPreferredOrientation();
53939     } catch (std::out_of_range& e) {
53940       {
53941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53942       };
53943     } catch (std::exception& e) {
53944       {
53945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53946       };
53947     } catch (...) {
53948       {
53949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53950       };
53951     }
53952   }
53953   jresult = (int)result;
53954   return jresult;
53955 }
53956
53957
53958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetDragAndDropDetector(void * jarg1) {
53959   void * jresult ;
53960   Dali::Window *arg1 = (Dali::Window *) 0 ;
53961   Dali::DragAndDropDetector result;
53962
53963   arg1 = (Dali::Window *)jarg1;
53964   {
53965     try {
53966       result = ((Dali::Window const *)arg1)->GetDragAndDropDetector();
53967     } catch (std::out_of_range& e) {
53968       {
53969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53970       };
53971     } catch (std::exception& e) {
53972       {
53973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53974       };
53975     } catch (...) {
53976       {
53977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53978       };
53979     }
53980   }
53981   jresult = new Dali::DragAndDropDetector((const Dali::DragAndDropDetector &)result);
53982   return jresult;
53983 }
53984
53985
53986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Window_GetNativeHandle(void * jarg1) {
53987   void * jresult ;
53988   Dali::Window *arg1 = (Dali::Window *) 0 ;
53989   Dali::Any result;
53990
53991   arg1 = (Dali::Window *)jarg1;
53992   {
53993     try {
53994       result = ((Dali::Window const *)arg1)->GetNativeHandle();
53995     } catch (std::out_of_range& e) {
53996       {
53997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53998       };
53999     } catch (std::exception& e) {
54000       {
54001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54002       };
54003     } catch (...) {
54004       {
54005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54006       };
54007     }
54008   }
54009   jresult = new Dali::Any((const Dali::Any &)result);
54010   return jresult;
54011 }
54012
54013
54014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FocusChangedSignal(void * jarg1) {
54015   void * jresult ;
54016   Dali::Window arg1 ;
54017   Dali::Window *argp1 ;
54018   Dali::DevelWindow::FocusSignalType *result = 0 ;
54019
54020   argp1 = (Dali::Window *)jarg1;
54021   if (!argp1) {
54022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54023     return 0;
54024   }
54025   arg1 = *argp1;
54026   {
54027     try {
54028       result = (Dali::DevelWindow::FocusSignalType *) &Dali::DevelWindow::FocusChangedSignal(arg1);
54029     } catch (std::out_of_range& e) {
54030       {
54031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54032       };
54033     } catch (std::exception& e) {
54034       {
54035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54036       };
54037     } catch (...) {
54038       {
54039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54040       };
54041     }
54042   }
54043   jresult = (void *)result;
54044   return jresult;
54045 }
54046
54047
54048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetAcceptFocus(void * jarg1, unsigned int jarg2) {
54049   Dali::Window arg1 ;
54050   bool arg2 ;
54051   Dali::Window *argp1 ;
54052
54053   argp1 = (Dali::Window *)jarg1;
54054   if (!argp1) {
54055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54056     return ;
54057   }
54058   arg1 = *argp1;
54059   arg2 = jarg2 ? true : false;
54060   {
54061     try {
54062       Dali::DevelWindow::SetAcceptFocus(arg1,arg2);
54063     } catch (std::out_of_range& e) {
54064       {
54065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54066       };
54067     } catch (std::exception& e) {
54068       {
54069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54070       };
54071     } catch (...) {
54072       {
54073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54074       };
54075     }
54076   }
54077 }
54078
54079
54080 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsFocusAcceptable(void * jarg1) {
54081   unsigned int jresult ;
54082   Dali::Window arg1 ;
54083   Dali::Window *argp1 ;
54084   bool result;
54085
54086   argp1 = (Dali::Window *)jarg1;
54087   if (!argp1) {
54088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54089     return 0;
54090   }
54091   arg1 = *argp1;
54092   {
54093     try {
54094       result = (bool)Dali::DevelWindow::IsFocusAcceptable(arg1);
54095     } catch (std::out_of_range& e) {
54096       {
54097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54098       };
54099     } catch (std::exception& e) {
54100       {
54101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54102       };
54103     } catch (...) {
54104       {
54105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54106       };
54107     }
54108   }
54109   jresult = result;
54110   return jresult;
54111 }
54112
54113
54114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Show(void * jarg1) {
54115   Dali::Window arg1 ;
54116   Dali::Window *argp1 ;
54117
54118   argp1 = (Dali::Window *)jarg1;
54119   if (!argp1) {
54120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54121     return ;
54122   }
54123   arg1 = *argp1;
54124   {
54125     try {
54126       Dali::DevelWindow::Show(arg1);
54127     } catch (std::out_of_range& e) {
54128       {
54129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54130       };
54131     } catch (std::exception& e) {
54132       {
54133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54134       };
54135     } catch (...) {
54136       {
54137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54138       };
54139     }
54140   }
54141 }
54142
54143
54144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hide(void * jarg1) {
54145   Dali::Window arg1 ;
54146   Dali::Window *argp1 ;
54147
54148   argp1 = (Dali::Window *)jarg1;
54149   if (!argp1) {
54150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54151     return ;
54152   }
54153   arg1 = *argp1;
54154   {
54155     try {
54156       Dali::DevelWindow::Hide(arg1);
54157     } catch (std::out_of_range& e) {
54158       {
54159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54160       };
54161     } catch (std::exception& e) {
54162       {
54163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54164       };
54165     } catch (...) {
54166       {
54167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54168       };
54169     }
54170   }
54171 }
54172
54173
54174 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVisible(void * jarg1) {
54175   unsigned int jresult ;
54176   Dali::Window arg1 ;
54177   Dali::Window *argp1 ;
54178   bool result;
54179
54180   argp1 = (Dali::Window *)jarg1;
54181   if (!argp1) {
54182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
54183     return 0;
54184   }
54185   arg1 = *argp1;
54186   {
54187     try {
54188       result = (bool)Dali::DevelWindow::IsVisible(arg1);
54189     } catch (std::out_of_range& e) {
54190       {
54191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54192       };
54193     } catch (std::exception& e) {
54194       {
54195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54196       };
54197     } catch (...) {
54198       {
54199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54200       };
54201     }
54202   }
54203   jresult = result;
54204   return jresult;
54205 }
54206
54207
54208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_0() {
54209   void * jresult ;
54210   Dali::Application result;
54211
54212   {
54213     try {
54214       result = Dali::Application::New();
54215     } catch (std::out_of_range& e) {
54216       {
54217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54218       };
54219     } catch (std::exception& e) {
54220       {
54221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54222       };
54223     } catch (...) {
54224       {
54225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54226       };
54227     }
54228   }
54229   jresult = new Dali::Application((const Dali::Application &)result);
54230   return jresult;
54231 }
54232
54233
54234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_1(int jarg1) {
54235   void * jresult ;
54236   int *arg1 = (int *) 0 ;
54237   char ***arg2 ;
54238   Dali::Application result;
54239
54240   {
54241     // Todo generate argv data from the C# args
54242     char **array;         // two dimensional array
54243     int numStrings = 1;     // number of strings
54244     int stringLength = 30;      // max string length.
54245     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54246     argV = array;
54247
54248     // allocate the string data
54249     for( int i=0; i < numStrings; i++)
54250     {
54251       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54252     }
54253     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54254
54255     strcpy( array[0], "dali-csharp-app");
54256
54257     arg1 = &argC;
54258     arg2 = &argV;
54259   }
54260   {
54261     try {
54262       result = Dali::Application::New(arg1,arg2);
54263     } catch (std::out_of_range& e) {
54264       {
54265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54266       };
54267     } catch (std::exception& e) {
54268       {
54269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54270       };
54271     } catch (...) {
54272       {
54273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54274       };
54275     }
54276   }
54277   jresult = new Dali::Application((const Dali::Application &)result);
54278   return jresult;
54279 }
54280
54281
54282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_2(int jarg1, char * jarg3) {
54283   void * jresult ;
54284   int *arg1 = (int *) 0 ;
54285   char ***arg2 ;
54286   std::string *arg3 = 0 ;
54287   Dali::Application result;
54288
54289   {
54290     // Todo generate argv data from the C# args
54291     char **array;         // two dimensional array
54292     int numStrings = 1;     // number of strings
54293     int stringLength = 30;      // max string length.
54294     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54295     argV = array;
54296
54297     // allocate the string data
54298     for( int i=0; i < numStrings; i++)
54299     {
54300       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54301     }
54302     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54303
54304     strcpy( array[0], "dali-csharp-app");
54305
54306     arg1 = &argC;
54307     arg2 = &argV;
54308   }
54309   if (!jarg3) {
54310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54311     return 0;
54312   }
54313   std::string arg3_str(jarg3);
54314   arg3 = &arg3_str;
54315   {
54316     try {
54317       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3);
54318     } catch (std::out_of_range& e) {
54319       {
54320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54321       };
54322     } catch (std::exception& e) {
54323       {
54324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54325       };
54326     } catch (...) {
54327       {
54328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54329       };
54330     }
54331   }
54332   jresult = new Dali::Application((const Dali::Application &)result);
54333
54334   //argout typemap for const std::string&
54335
54336   return jresult;
54337 }
54338
54339
54340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_New__SWIG_3(int jarg1, char * jarg3, int jarg4) {
54341   void * jresult ;
54342   int *arg1 = (int *) 0 ;
54343   char ***arg2 ;
54344   std::string *arg3 = 0 ;
54345   Dali::Application::WINDOW_MODE arg4 ;
54346   Dali::Application result;
54347
54348   {
54349     // Todo generate argv data from the C# args
54350     char **array;         // two dimensional array
54351     int numStrings = 1;     // number of strings
54352     int stringLength = 30;      // max string length.
54353     array = (char **)malloc( (numStrings + 1 )* sizeof(char *) );
54354     argV = array;
54355
54356     // allocate the string data
54357     for( int i=0; i < numStrings; i++)
54358     {
54359       array[i]=(char *)malloc( stringLength * sizeof(char *) );
54360     }
54361     array[ numStrings ] =  NULL; // we allocated +1 for hold the NULL part
54362
54363     strcpy( array[0], "dali-csharp-app");
54364
54365     arg1 = &argC;
54366     arg2 = &argV;
54367   }
54368   if (!jarg3) {
54369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54370     return 0;
54371   }
54372   std::string arg3_str(jarg3);
54373   arg3 = &arg3_str;
54374   arg4 = (Dali::Application::WINDOW_MODE)jarg4;
54375   {
54376     try {
54377       result = Dali::Application::New(arg1,arg2,(std::string const &)*arg3,arg4);
54378     } catch (std::out_of_range& e) {
54379       {
54380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54381       };
54382     } catch (std::exception& e) {
54383       {
54384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54385       };
54386     } catch (...) {
54387       {
54388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54389       };
54390     }
54391   }
54392   jresult = new Dali::Application((const Dali::Application &)result);
54393
54394   //argout typemap for const std::string&
54395
54396   return jresult;
54397 }
54398
54399
54400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_0() {
54401   void * jresult ;
54402   Dali::Application *result = 0 ;
54403
54404   {
54405     try {
54406       result = (Dali::Application *)new Dali::Application();
54407     } catch (std::out_of_range& e) {
54408       {
54409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54410       };
54411     } catch (std::exception& e) {
54412       {
54413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54414       };
54415     } catch (...) {
54416       {
54417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54418       };
54419     }
54420   }
54421   jresult = (void *)result;
54422   return jresult;
54423 }
54424
54425
54426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Application__SWIG_1(void * jarg1) {
54427   void * jresult ;
54428   Dali::Application *arg1 = 0 ;
54429   Dali::Application *result = 0 ;
54430
54431   arg1 = (Dali::Application *)jarg1;
54432   if (!arg1) {
54433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54434     return 0;
54435   }
54436   {
54437     try {
54438       result = (Dali::Application *)new Dali::Application((Dali::Application const &)*arg1);
54439     } catch (std::out_of_range& e) {
54440       {
54441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54442       };
54443     } catch (std::exception& e) {
54444       {
54445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54446       };
54447     } catch (...) {
54448       {
54449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54450       };
54451     }
54452   }
54453   jresult = (void *)result;
54454   return jresult;
54455 }
54456
54457
54458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_Assign(void * jarg1, void * jarg2) {
54459   void * jresult ;
54460   Dali::Application *arg1 = (Dali::Application *) 0 ;
54461   Dali::Application *arg2 = 0 ;
54462   Dali::Application *result = 0 ;
54463
54464   arg1 = (Dali::Application *)jarg1;
54465   arg2 = (Dali::Application *)jarg2;
54466   if (!arg2) {
54467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application const & type is null", 0);
54468     return 0;
54469   }
54470   {
54471     try {
54472       result = (Dali::Application *) &(arg1)->operator =((Dali::Application const &)*arg2);
54473     } catch (std::out_of_range& e) {
54474       {
54475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54476       };
54477     } catch (std::exception& e) {
54478       {
54479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54480       };
54481     } catch (...) {
54482       {
54483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54484       };
54485     }
54486   }
54487   jresult = (void *)result;
54488   return jresult;
54489 }
54490
54491
54492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Application(void * jarg1) {
54493   Dali::Application *arg1 = (Dali::Application *) 0 ;
54494
54495   arg1 = (Dali::Application *)jarg1;
54496   {
54497     try {
54498       delete arg1;
54499     } catch (std::out_of_range& e) {
54500       {
54501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54502       };
54503     } catch (std::exception& e) {
54504       {
54505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54506       };
54507     } catch (...) {
54508       {
54509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54510       };
54511     }
54512   }
54513 }
54514
54515
54516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_0(void * jarg1) {
54517   Dali::Application *arg1 = (Dali::Application *) 0 ;
54518
54519   arg1 = (Dali::Application *)jarg1;
54520   {
54521     try {
54522       (arg1)->MainLoop();
54523     } catch (std::out_of_range& e) {
54524       {
54525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54526       };
54527     } catch (std::exception& e) {
54528       {
54529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54530       };
54531     } catch (...) {
54532       {
54533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54534       };
54535     }
54536   }
54537 }
54538
54539
54540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_MainLoop__SWIG_1(void * jarg1, void * jarg2) {
54541   Dali::Application *arg1 = (Dali::Application *) 0 ;
54542   Configuration::ContextLoss arg2 ;
54543   Configuration::ContextLoss *argp2 ;
54544
54545   arg1 = (Dali::Application *)jarg1;
54546   argp2 = (Configuration::ContextLoss *)jarg2;
54547   if (!argp2) {
54548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Configuration::ContextLoss", 0);
54549     return ;
54550   }
54551   arg2 = *argp2;
54552   {
54553     try {
54554       (arg1)->MainLoop(arg2);
54555     } catch (std::out_of_range& e) {
54556       {
54557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54558       };
54559     } catch (std::exception& e) {
54560       {
54561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54562       };
54563     } catch (...) {
54564       {
54565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54566       };
54567     }
54568   }
54569 }
54570
54571
54572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Lower(void * jarg1) {
54573   Dali::Application *arg1 = (Dali::Application *) 0 ;
54574
54575   arg1 = (Dali::Application *)jarg1;
54576   {
54577     try {
54578       (arg1)->Lower();
54579     } catch (std::out_of_range& e) {
54580       {
54581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54582       };
54583     } catch (std::exception& e) {
54584       {
54585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54586       };
54587     } catch (...) {
54588       {
54589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54590       };
54591     }
54592   }
54593 }
54594
54595
54596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_Quit(void * jarg1) {
54597   Dali::Application *arg1 = (Dali::Application *) 0 ;
54598
54599   arg1 = (Dali::Application *)jarg1;
54600   {
54601     try {
54602       (arg1)->Quit();
54603     } catch (std::out_of_range& e) {
54604       {
54605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54606       };
54607     } catch (std::exception& e) {
54608       {
54609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54610       };
54611     } catch (...) {
54612       {
54613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54614       };
54615     }
54616   }
54617 }
54618
54619
54620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Application_AddIdle(void * jarg1, void * jarg2) {
54621   unsigned int jresult ;
54622   Dali::Application *arg1 = (Dali::Application *) 0 ;
54623   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
54624   bool result;
54625
54626   arg1 = (Dali::Application *)jarg1;
54627   arg2 = (Dali::CallbackBase *)jarg2;
54628   {
54629     try {
54630       result = (bool)(arg1)->AddIdle(arg2);
54631     } catch (std::out_of_range& e) {
54632       {
54633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54634       };
54635     } catch (std::exception& e) {
54636       {
54637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54638       };
54639     } catch (...) {
54640       {
54641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54642       };
54643     }
54644   }
54645   jresult = result;
54646   return jresult;
54647 }
54648
54649
54650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_GetWindow(void * jarg1) {
54651   void * jresult ;
54652   Dali::Application *arg1 = (Dali::Application *) 0 ;
54653   Dali::Window result;
54654
54655   arg1 = (Dali::Application *)jarg1;
54656   {
54657     try {
54658       result = (arg1)->GetWindow();
54659     } catch (std::out_of_range& e) {
54660       {
54661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54662       };
54663     } catch (std::exception& e) {
54664       {
54665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54666       };
54667     } catch (...) {
54668       {
54669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54670       };
54671     }
54672   }
54673   jresult = new Dali::Window((const Dali::Window &)result);
54674   return jresult;
54675 }
54676
54677
54678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_ReplaceWindow(void * jarg1, void * jarg2, char * jarg3) {
54679   Dali::Application *arg1 = (Dali::Application *) 0 ;
54680   Dali::PositionSize arg2 ;
54681   std::string *arg3 = 0 ;
54682   Dali::PositionSize *argp2 ;
54683
54684   arg1 = (Dali::Application *)jarg1;
54685   argp2 = (Dali::PositionSize *)jarg2;
54686   if (!argp2) {
54687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PositionSize", 0);
54688     return ;
54689   }
54690   arg2 = *argp2;
54691   if (!jarg3) {
54692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
54693     return ;
54694   }
54695   std::string arg3_str(jarg3);
54696   arg3 = &arg3_str;
54697   {
54698     try {
54699       (arg1)->ReplaceWindow(arg2,(std::string const &)*arg3);
54700     } catch (std::out_of_range& e) {
54701       {
54702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54703       };
54704     } catch (std::exception& e) {
54705       {
54706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54707       };
54708     } catch (...) {
54709       {
54710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54711       };
54712     }
54713   }
54714
54715   //argout typemap for const std::string&
54716
54717 }
54718
54719
54720 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Application_GetResourcePath() {
54721   char * jresult ;
54722   std::string result;
54723
54724   {
54725     try {
54726       result = Dali::Application::GetResourcePath();
54727     } catch (std::out_of_range& e) {
54728       {
54729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54730       };
54731     } catch (std::exception& e) {
54732       {
54733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54734       };
54735     } catch (...) {
54736       {
54737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54738       };
54739     }
54740   }
54741   jresult = SWIG_csharp_string_callback((&result)->c_str());
54742   return jresult;
54743 }
54744
54745
54746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetViewMode(void * jarg1, int jarg2) {
54747   Dali::Application *arg1 = (Dali::Application *) 0 ;
54748   Dali::ViewMode arg2 ;
54749
54750   arg1 = (Dali::Application *)jarg1;
54751   arg2 = (Dali::ViewMode)jarg2;
54752   {
54753     try {
54754       (arg1)->SetViewMode(arg2);
54755     } catch (std::out_of_range& e) {
54756       {
54757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54758       };
54759     } catch (std::exception& e) {
54760       {
54761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54762       };
54763     } catch (...) {
54764       {
54765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54766       };
54767     }
54768   }
54769 }
54770
54771
54772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Application_GetViewMode(void * jarg1) {
54773   int jresult ;
54774   Dali::Application *arg1 = (Dali::Application *) 0 ;
54775   Dali::ViewMode result;
54776
54777   arg1 = (Dali::Application *)jarg1;
54778   {
54779     try {
54780       result = (Dali::ViewMode)((Dali::Application const *)arg1)->GetViewMode();
54781     } catch (std::out_of_range& e) {
54782       {
54783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54784       };
54785     } catch (std::exception& e) {
54786       {
54787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54788       };
54789     } catch (...) {
54790       {
54791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54792       };
54793     }
54794   }
54795   jresult = (int)result;
54796   return jresult;
54797 }
54798
54799
54800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Application_SetStereoBase(void * jarg1, float jarg2) {
54801   Dali::Application *arg1 = (Dali::Application *) 0 ;
54802   float arg2 ;
54803
54804   arg1 = (Dali::Application *)jarg1;
54805   arg2 = (float)jarg2;
54806   {
54807     try {
54808       (arg1)->SetStereoBase(arg2);
54809     } catch (std::out_of_range& e) {
54810       {
54811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54812       };
54813     } catch (std::exception& e) {
54814       {
54815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54816       };
54817     } catch (...) {
54818       {
54819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54820       };
54821     }
54822   }
54823 }
54824
54825
54826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Application_GetStereoBase(void * jarg1) {
54827   float jresult ;
54828   Dali::Application *arg1 = (Dali::Application *) 0 ;
54829   float result;
54830
54831   arg1 = (Dali::Application *)jarg1;
54832   {
54833     try {
54834       result = (float)((Dali::Application const *)arg1)->GetStereoBase();
54835     } catch (std::out_of_range& e) {
54836       {
54837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54838       };
54839     } catch (std::exception& e) {
54840       {
54841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54842       };
54843     } catch (...) {
54844       {
54845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54846       };
54847     }
54848   }
54849   jresult = result;
54850   return jresult;
54851 }
54852
54853
54854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_InitSignal(void * jarg1) {
54855   void * jresult ;
54856   Dali::Application *arg1 = (Dali::Application *) 0 ;
54857   Dali::Application::AppSignalType *result = 0 ;
54858
54859   arg1 = (Dali::Application *)jarg1;
54860   {
54861     try {
54862       result = (Dali::Application::AppSignalType *) &(arg1)->InitSignal();
54863     } catch (std::out_of_range& e) {
54864       {
54865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54866       };
54867     } catch (std::exception& e) {
54868       {
54869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54870       };
54871     } catch (...) {
54872       {
54873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54874       };
54875     }
54876   }
54877   jresult = (void *)result;
54878   return jresult;
54879 }
54880
54881
54882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_TerminateSignal(void * jarg1) {
54883   void * jresult ;
54884   Dali::Application *arg1 = (Dali::Application *) 0 ;
54885   Dali::Application::AppSignalType *result = 0 ;
54886
54887   arg1 = (Dali::Application *)jarg1;
54888   {
54889     try {
54890       result = (Dali::Application::AppSignalType *) &(arg1)->TerminateSignal();
54891     } catch (std::out_of_range& e) {
54892       {
54893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54894       };
54895     } catch (std::exception& e) {
54896       {
54897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54898       };
54899     } catch (...) {
54900       {
54901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54902       };
54903     }
54904   }
54905   jresult = (void *)result;
54906   return jresult;
54907 }
54908
54909
54910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_PauseSignal(void * jarg1) {
54911   void * jresult ;
54912   Dali::Application *arg1 = (Dali::Application *) 0 ;
54913   Dali::Application::AppSignalType *result = 0 ;
54914
54915   arg1 = (Dali::Application *)jarg1;
54916   {
54917     try {
54918       result = (Dali::Application::AppSignalType *) &(arg1)->PauseSignal();
54919     } catch (std::out_of_range& e) {
54920       {
54921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54922       };
54923     } catch (std::exception& e) {
54924       {
54925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54926       };
54927     } catch (...) {
54928       {
54929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54930       };
54931     }
54932   }
54933   jresult = (void *)result;
54934   return jresult;
54935 }
54936
54937
54938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResumeSignal(void * jarg1) {
54939   void * jresult ;
54940   Dali::Application *arg1 = (Dali::Application *) 0 ;
54941   Dali::Application::AppSignalType *result = 0 ;
54942
54943   arg1 = (Dali::Application *)jarg1;
54944   {
54945     try {
54946       result = (Dali::Application::AppSignalType *) &(arg1)->ResumeSignal();
54947     } catch (std::out_of_range& e) {
54948       {
54949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54950       };
54951     } catch (std::exception& e) {
54952       {
54953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54954       };
54955     } catch (...) {
54956       {
54957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54958       };
54959     }
54960   }
54961   jresult = (void *)result;
54962   return jresult;
54963 }
54964
54965
54966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResetSignal(void * jarg1) {
54967   void * jresult ;
54968   Dali::Application *arg1 = (Dali::Application *) 0 ;
54969   Dali::Application::AppSignalType *result = 0 ;
54970
54971   arg1 = (Dali::Application *)jarg1;
54972   {
54973     try {
54974       result = (Dali::Application::AppSignalType *) &(arg1)->ResetSignal();
54975     } catch (std::out_of_range& e) {
54976       {
54977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54978       };
54979     } catch (std::exception& e) {
54980       {
54981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54982       };
54983     } catch (...) {
54984       {
54985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54986       };
54987     }
54988   }
54989   jresult = (void *)result;
54990   return jresult;
54991 }
54992
54993
54994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_ResizeSignal(void * jarg1) {
54995   void * jresult ;
54996   Dali::Application *arg1 = (Dali::Application *) 0 ;
54997   Dali::Application::AppSignalType *result = 0 ;
54998
54999   arg1 = (Dali::Application *)jarg1;
55000   {
55001     try {
55002       result = (Dali::Application::AppSignalType *) &(arg1)->ResizeSignal();
55003     } catch (std::out_of_range& e) {
55004       {
55005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55006       };
55007     } catch (std::exception& e) {
55008       {
55009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55010       };
55011     } catch (...) {
55012       {
55013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55014       };
55015     }
55016   }
55017   jresult = (void *)result;
55018   return jresult;
55019 }
55020
55021
55022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_AppControlSignal(void * jarg1) {
55023   void * jresult ;
55024   Dali::Application *arg1 = (Dali::Application *) 0 ;
55025   Dali::Application::AppControlSignalType *result = 0 ;
55026
55027   arg1 = (Dali::Application *)jarg1;
55028   {
55029     try {
55030       result = (Dali::Application::AppControlSignalType *) &(arg1)->AppControlSignal();
55031     } catch (std::out_of_range& e) {
55032       {
55033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55034       };
55035     } catch (std::exception& e) {
55036       {
55037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55038       };
55039     } catch (...) {
55040       {
55041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55042       };
55043     }
55044   }
55045   jresult = (void *)result;
55046   return jresult;
55047 }
55048
55049
55050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_LanguageChangedSignal(void * jarg1) {
55051   void * jresult ;
55052   Dali::Application *arg1 = (Dali::Application *) 0 ;
55053   Dali::Application::AppSignalType *result = 0 ;
55054
55055   arg1 = (Dali::Application *)jarg1;
55056   {
55057     try {
55058       result = (Dali::Application::AppSignalType *) &(arg1)->LanguageChangedSignal();
55059     } catch (std::out_of_range& e) {
55060       {
55061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55062       };
55063     } catch (std::exception& e) {
55064       {
55065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55066       };
55067     } catch (...) {
55068       {
55069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55070       };
55071     }
55072   }
55073   jresult = (void *)result;
55074   return jresult;
55075 }
55076
55077
55078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_RegionChangedSignal(void * jarg1) {
55079   void * jresult ;
55080   Dali::Application *arg1 = (Dali::Application *) 0 ;
55081   Dali::Application::AppSignalType *result = 0 ;
55082
55083   arg1 = (Dali::Application *)jarg1;
55084   {
55085     try {
55086       result = (Dali::Application::AppSignalType *) &(arg1)->RegionChangedSignal();
55087     } catch (std::out_of_range& e) {
55088       {
55089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55090       };
55091     } catch (std::exception& e) {
55092       {
55093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55094       };
55095     } catch (...) {
55096       {
55097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55098       };
55099     }
55100   }
55101   jresult = (void *)result;
55102   return jresult;
55103 }
55104
55105
55106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_BatteryLowSignal(void * jarg1) {
55107   void * jresult ;
55108   Dali::Application *arg1 = (Dali::Application *) 0 ;
55109   Dali::Application::AppSignalType *result = 0 ;
55110
55111   arg1 = (Dali::Application *)jarg1;
55112   {
55113     try {
55114       result = (Dali::Application::AppSignalType *) &(arg1)->BatteryLowSignal();
55115     } catch (std::out_of_range& e) {
55116       {
55117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55118       };
55119     } catch (std::exception& e) {
55120       {
55121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55122       };
55123     } catch (...) {
55124       {
55125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55126       };
55127     }
55128   }
55129   jresult = (void *)result;
55130   return jresult;
55131 }
55132
55133
55134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Application_MemoryLowSignal(void * jarg1) {
55135   void * jresult ;
55136   Dali::Application *arg1 = (Dali::Application *) 0 ;
55137   Dali::Application::AppSignalType *result = 0 ;
55138
55139   arg1 = (Dali::Application *)jarg1;
55140   {
55141     try {
55142       result = (Dali::Application::AppSignalType *) &(arg1)->MemoryLowSignal();
55143     } catch (std::out_of_range& e) {
55144       {
55145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55146       };
55147     } catch (std::exception& e) {
55148       {
55149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55150       };
55151     } catch (...) {
55152       {
55153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55154       };
55155     }
55156   }
55157   jresult = (void *)result;
55158   return jresult;
55159 }
55160
55161
55162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationSignal_Empty(void * jarg1) {
55163   unsigned int jresult ;
55164   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55165   bool result;
55166
55167   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55168   {
55169     try {
55170       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Application &) > const *)arg1);
55171     } catch (std::out_of_range& e) {
55172       {
55173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55174       };
55175     } catch (std::exception& e) {
55176       {
55177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55178       };
55179     } catch (...) {
55180       {
55181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55182       };
55183     }
55184   }
55185   jresult = result;
55186   return jresult;
55187 }
55188
55189
55190 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationSignal_GetConnectionCount(void * jarg1) {
55191   unsigned long jresult ;
55192   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55193   std::size_t result;
55194
55195   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55196   {
55197     try {
55198       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &) > const *)arg1);
55199     } catch (std::out_of_range& e) {
55200       {
55201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55202       };
55203     } catch (std::exception& e) {
55204       {
55205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55206       };
55207     } catch (...) {
55208       {
55209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55210       };
55211     }
55212   }
55213   jresult = (unsigned long)result;
55214   return jresult;
55215 }
55216
55217
55218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Connect(void * jarg1, void * jarg2) {
55219   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55220   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55221
55222   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55223   arg2 = (void (*)(Dali::Application &))jarg2;
55224   {
55225     try {
55226       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Connect(arg1,arg2);
55227     } catch (std::out_of_range& e) {
55228       {
55229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55230       };
55231     } catch (std::exception& e) {
55232       {
55233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55234       };
55235     } catch (...) {
55236       {
55237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55238       };
55239     }
55240   }
55241 }
55242
55243
55244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Disconnect(void * jarg1, void * jarg2) {
55245   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55246   void (*arg2)(Dali::Application &) = (void (*)(Dali::Application &)) 0 ;
55247
55248   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55249   arg2 = (void (*)(Dali::Application &))jarg2;
55250   {
55251     try {
55252       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Disconnect(arg1,arg2);
55253     } catch (std::out_of_range& e) {
55254       {
55255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55256       };
55257     } catch (std::exception& e) {
55258       {
55259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55260       };
55261     } catch (...) {
55262       {
55263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55264       };
55265     }
55266   }
55267 }
55268
55269
55270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationSignal_Emit(void * jarg1, void * jarg2) {
55271   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55272   Dali::Application *arg2 = 0 ;
55273
55274   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55275   arg2 = (Dali::Application *)jarg2;
55276   if (!arg2) {
55277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55278     return ;
55279   }
55280   {
55281     try {
55282       Dali_Signal_Sl_void_Sp_Dali_Application_SA__SP__Sg__Emit(arg1,*arg2);
55283     } catch (std::out_of_range& e) {
55284       {
55285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55286       };
55287     } catch (std::exception& e) {
55288       {
55289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55290       };
55291     } catch (...) {
55292       {
55293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55294       };
55295     }
55296   }
55297 }
55298
55299
55300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationSignal() {
55301   void * jresult ;
55302   Dali::Signal< void (Dali::Application &) > *result = 0 ;
55303
55304   {
55305     try {
55306       result = (Dali::Signal< void (Dali::Application &) > *)new Dali::Signal< void (Dali::Application &) >();
55307     } catch (std::out_of_range& e) {
55308       {
55309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55310       };
55311     } catch (std::exception& e) {
55312       {
55313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55314       };
55315     } catch (...) {
55316       {
55317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55318       };
55319     }
55320   }
55321   jresult = (void *)result;
55322   return jresult;
55323 }
55324
55325
55326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationSignal(void * jarg1) {
55327   Dali::Signal< void (Dali::Application &) > *arg1 = (Dali::Signal< void (Dali::Application &) > *) 0 ;
55328
55329   arg1 = (Dali::Signal< void (Dali::Application &) > *)jarg1;
55330   {
55331     try {
55332       delete arg1;
55333     } catch (std::out_of_range& e) {
55334       {
55335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55336       };
55337     } catch (std::exception& e) {
55338       {
55339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55340       };
55341     } catch (...) {
55342       {
55343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55344       };
55345     }
55346   }
55347 }
55348
55349
55350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Empty(void * jarg1) {
55351   unsigned int jresult ;
55352   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55353   bool result;
55354
55355   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55356   {
55357     try {
55358       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55359     } catch (std::out_of_range& e) {
55360       {
55361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55362       };
55363     } catch (std::exception& e) {
55364       {
55365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55366       };
55367     } catch (...) {
55368       {
55369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55370       };
55371     }
55372   }
55373   jresult = result;
55374   return jresult;
55375 }
55376
55377
55378 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_GetConnectionCount(void * jarg1) {
55379   unsigned long jresult ;
55380   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55381   std::size_t result;
55382
55383   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55384   {
55385     try {
55386       result = Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Application &,void *) > const *)arg1);
55387     } catch (std::out_of_range& e) {
55388       {
55389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55390       };
55391     } catch (std::exception& e) {
55392       {
55393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55394       };
55395     } catch (...) {
55396       {
55397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55398       };
55399     }
55400   }
55401   jresult = (unsigned long)result;
55402   return jresult;
55403 }
55404
55405
55406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Connect(void * jarg1, void * jarg2) {
55407   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55408   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55409
55410   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55411   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55412   {
55413     try {
55414       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Connect(arg1,arg2);
55415     } catch (std::out_of_range& e) {
55416       {
55417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55418       };
55419     } catch (std::exception& e) {
55420       {
55421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55422       };
55423     } catch (...) {
55424       {
55425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55426       };
55427     }
55428   }
55429 }
55430
55431
55432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Disconnect(void * jarg1, void * jarg2) {
55433   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55434   void (*arg2)(Dali::Application &,void *) = (void (*)(Dali::Application &,void *)) 0 ;
55435
55436   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55437   arg2 = (void (*)(Dali::Application &,void *))jarg2;
55438   {
55439     try {
55440       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Disconnect(arg1,arg2);
55441     } catch (std::out_of_range& e) {
55442       {
55443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55444       };
55445     } catch (std::exception& e) {
55446       {
55447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55448       };
55449     } catch (...) {
55450       {
55451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55452       };
55453     }
55454   }
55455 }
55456
55457
55458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationControlSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55459   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55460   Dali::Application *arg2 = 0 ;
55461   void *arg3 = (void *) 0 ;
55462
55463   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55464   arg2 = (Dali::Application *)jarg2;
55465   if (!arg2) {
55466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Application & type is null", 0);
55467     return ;
55468   }
55469   arg3 = jarg3;
55470   {
55471     try {
55472       Dali_Signal_Sl_void_Sp_Dali_Application_SA__Sc_void_Sm__SP__Sg__Emit(arg1,*arg2,arg3);
55473     } catch (std::out_of_range& e) {
55474       {
55475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55476       };
55477     } catch (std::exception& e) {
55478       {
55479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55480       };
55481     } catch (...) {
55482       {
55483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55484       };
55485     }
55486   }
55487 }
55488
55489
55490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationControlSignal() {
55491   void * jresult ;
55492   Dali::Signal< void (Dali::Application &,void *) > *result = 0 ;
55493
55494   {
55495     try {
55496       result = (Dali::Signal< void (Dali::Application &,void *) > *)new Dali::Signal< void (Dali::Application &,void *) >();
55497     } catch (std::out_of_range& e) {
55498       {
55499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55500       };
55501     } catch (std::exception& e) {
55502       {
55503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55504       };
55505     } catch (...) {
55506       {
55507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55508       };
55509     }
55510   }
55511   jresult = (void *)result;
55512   return jresult;
55513 }
55514
55515
55516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationControlSignal(void * jarg1) {
55517   Dali::Signal< void (Dali::Application &,void *) > *arg1 = (Dali::Signal< void (Dali::Application &,void *) > *) 0 ;
55518
55519   arg1 = (Dali::Signal< void (Dali::Application &,void *) > *)jarg1;
55520   {
55521     try {
55522       delete arg1;
55523     } catch (std::out_of_range& e) {
55524       {
55525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55526       };
55527     } catch (std::exception& e) {
55528       {
55529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55530       };
55531     } catch (...) {
55532       {
55533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55534       };
55535     }
55536   }
55537 }
55538
55539
55540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55541   unsigned int jresult ;
55542   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55543   bool result;
55544
55545   arg1 = (Dali::Signal< bool () > *)jarg1;
55546   {
55547     try {
55548       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55549     } catch (std::out_of_range& e) {
55550       {
55551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55552       };
55553     } catch (std::exception& e) {
55554       {
55555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55556       };
55557     } catch (...) {
55558       {
55559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55560       };
55561     }
55562   }
55563   jresult = result;
55564   return jresult;
55565 }
55566
55567
55568 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55569   unsigned long jresult ;
55570   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55571   std::size_t result;
55572
55573   arg1 = (Dali::Signal< bool () > *)jarg1;
55574   {
55575     try {
55576       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55577     } catch (std::out_of_range& e) {
55578       {
55579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55580       };
55581     } catch (std::exception& e) {
55582       {
55583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55584       };
55585     } catch (...) {
55586       {
55587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55588       };
55589     }
55590   }
55591   jresult = (unsigned long)result;
55592   return jresult;
55593 }
55594
55595
55596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55597   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55598   bool (*arg2)() = (bool (*)()) 0 ;
55599
55600   arg1 = (Dali::Signal< bool () > *)jarg1;
55601   arg2 = (bool (*)())jarg2;
55602   {
55603     try {
55604       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55605     } catch (std::out_of_range& e) {
55606       {
55607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55608       };
55609     } catch (std::exception& e) {
55610       {
55611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55612       };
55613     } catch (...) {
55614       {
55615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55616       };
55617     }
55618   }
55619 }
55620
55621
55622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55623   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55624   bool (*arg2)() = (bool (*)()) 0 ;
55625
55626   arg1 = (Dali::Signal< bool () > *)jarg1;
55627   arg2 = (bool (*)())jarg2;
55628   {
55629     try {
55630       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55631     } catch (std::out_of_range& e) {
55632       {
55633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55634       };
55635     } catch (std::exception& e) {
55636       {
55637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55638       };
55639     } catch (...) {
55640       {
55641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55642       };
55643     }
55644   }
55645 }
55646
55647
55648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55649   unsigned int jresult ;
55650   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55651   bool result;
55652
55653   arg1 = (Dali::Signal< bool () > *)jarg1;
55654   {
55655     try {
55656       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55657     } catch (std::out_of_range& e) {
55658       {
55659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55660       };
55661     } catch (std::exception& e) {
55662       {
55663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55664       };
55665     } catch (...) {
55666       {
55667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55668       };
55669     }
55670   }
55671   jresult = result;
55672   return jresult;
55673 }
55674
55675
55676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55677   void * jresult ;
55678   Dali::Signal< bool () > *result = 0 ;
55679
55680   {
55681     try {
55682       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55683     } catch (std::out_of_range& e) {
55684       {
55685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55686       };
55687     } catch (std::exception& e) {
55688       {
55689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55690       };
55691     } catch (...) {
55692       {
55693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55694       };
55695     }
55696   }
55697   jresult = (void *)result;
55698   return jresult;
55699 }
55700
55701
55702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55703   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55704
55705   arg1 = (Dali::Signal< bool () > *)jarg1;
55706   {
55707     try {
55708       delete arg1;
55709     } catch (std::out_of_range& e) {
55710       {
55711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55712       };
55713     } catch (std::exception& e) {
55714       {
55715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55716       };
55717     } catch (...) {
55718       {
55719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55720       };
55721     }
55722   }
55723 }
55724
55725
55726
55727
55728
55729 //manual merge 2017-03-31
55730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Empty(void * jarg1) {
55731   unsigned int jresult ;
55732   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55733   bool result;
55734
55735   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55736   {
55737     try {
55738       result = (bool)Dali_Signal_Sl_void_Sp_bool_SP__Sg__Empty((Dali::Signal< void (bool) > const *)arg1);
55739     } catch (std::out_of_range& e) {
55740       {
55741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55742       };
55743     } catch (std::exception& e) {
55744       {
55745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55746       };
55747     } catch (...) {
55748       {
55749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55750       };
55751     }
55752   }
55753   jresult = result;
55754   return jresult;
55755 }
55756
55757
55758 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_GetConnectionCount(void * jarg1) {
55759   unsigned long jresult ;
55760   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55761   std::size_t result;
55762
55763   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55764   {
55765     try {
55766       result = Dali_Signal_Sl_void_Sp_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (bool) > const *)arg1);
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 = (unsigned long)result;
55782   return jresult;
55783 }
55784
55785
55786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Connect(void * jarg1, void * jarg2) {
55787   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55788   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55789
55790   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55791   arg2 = (void (*)(bool))jarg2;
55792   {
55793     try {
55794       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Connect(arg1,arg2);
55795     } catch (std::out_of_range& e) {
55796       {
55797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55798       };
55799     } catch (std::exception& e) {
55800       {
55801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55802       };
55803     } catch (...) {
55804       {
55805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55806       };
55807     }
55808   }
55809 }
55810
55811
55812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Disconnect(void * jarg1, void * jarg2) {
55813   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55814   void (*arg2)(bool) = (void (*)(bool)) 0 ;
55815
55816   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55817   arg2 = (void (*)(bool))jarg2;
55818   {
55819     try {
55820       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Disconnect(arg1,arg2);
55821     } catch (std::out_of_range& e) {
55822       {
55823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55824       };
55825     } catch (std::exception& e) {
55826       {
55827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55828       };
55829     } catch (...) {
55830       {
55831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55832       };
55833     }
55834   }
55835 }
55836
55837
55838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WindowFocusSignalType_Emit(void * jarg1, unsigned int jarg2) {
55839   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55840   bool arg2 ;
55841
55842   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55843   arg2 = jarg2 ? true : false;
55844   {
55845     try {
55846       Dali_Signal_Sl_void_Sp_bool_SP__Sg__Emit(arg1,arg2);
55847     } catch (std::out_of_range& e) {
55848       {
55849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55850       };
55851     } catch (std::exception& e) {
55852       {
55853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55854       };
55855     } catch (...) {
55856       {
55857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55858       };
55859     }
55860   }
55861 }
55862
55863
55864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WindowFocusSignalType() {
55865   void * jresult ;
55866   Dali::Signal< void (bool) > *result = 0 ;
55867
55868   {
55869     try {
55870       result = (Dali::Signal< void (bool) > *)new Dali::Signal< void (bool) >();
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 = (void *)result;
55886   return jresult;
55887 }
55888
55889
55890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WindowFocusSignalType(void * jarg1) {
55891   Dali::Signal< void (bool) > *arg1 = (Dali::Signal< void (bool) > *) 0 ;
55892
55893   arg1 = (Dali::Signal< void (bool) > *)jarg1;
55894   {
55895     try {
55896       delete arg1;
55897     } catch (std::out_of_range& e) {
55898       {
55899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55900       };
55901     } catch (std::exception& e) {
55902       {
55903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55904       };
55905     } catch (...) {
55906       {
55907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55908       };
55909     }
55910   }
55911 }
55912
55913
55914
55915
55916
55917
55918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55919   int jresult ;
55920   int result;
55921
55922   {
55923     try {
55924       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55925     } catch (std::out_of_range& e) {
55926       {
55927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55928       };
55929     } catch (std::exception& e) {
55930       {
55931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55932       };
55933     } catch (...) {
55934       {
55935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55936       };
55937     }
55938   }
55939   jresult = (int)result;
55940   return jresult;
55941 }
55942
55943
55944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55945   int jresult ;
55946   int result;
55947
55948   {
55949     try {
55950       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55951     } catch (std::out_of_range& e) {
55952       {
55953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55954       };
55955     } catch (std::exception& e) {
55956       {
55957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55958       };
55959     } catch (...) {
55960       {
55961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55962       };
55963     }
55964   }
55965   jresult = (int)result;
55966   return jresult;
55967 }
55968
55969
55970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55971   int jresult ;
55972   int result;
55973
55974   {
55975     try {
55976       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55977     } catch (std::out_of_range& e) {
55978       {
55979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55980       };
55981     } catch (std::exception& e) {
55982       {
55983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55984       };
55985     } catch (...) {
55986       {
55987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55988       };
55989     }
55990   }
55991   jresult = (int)result;
55992   return jresult;
55993 }
55994
55995
55996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55997   int jresult ;
55998   int result;
55999
56000   {
56001     try {
56002       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
56003     } catch (std::out_of_range& e) {
56004       {
56005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56006       };
56007     } catch (std::exception& e) {
56008       {
56009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56010       };
56011     } catch (...) {
56012       {
56013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56014       };
56015     }
56016   }
56017   jresult = (int)result;
56018   return jresult;
56019 }
56020
56021
56022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
56023   int jresult ;
56024   int result;
56025
56026   {
56027     try {
56028       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
56029     } catch (std::out_of_range& e) {
56030       {
56031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56032       };
56033     } catch (std::exception& e) {
56034       {
56035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56036       };
56037     } catch (...) {
56038       {
56039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56040       };
56041     }
56042   }
56043   jresult = (int)result;
56044   return jresult;
56045 }
56046
56047
56048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
56049   int jresult ;
56050   int result;
56051
56052   {
56053     try {
56054       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
56055     } catch (std::out_of_range& e) {
56056       {
56057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56058       };
56059     } catch (std::exception& e) {
56060       {
56061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56062       };
56063     } catch (...) {
56064       {
56065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56066       };
56067     }
56068   }
56069   jresult = (int)result;
56070   return jresult;
56071 }
56072
56073
56074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
56075   int jresult ;
56076   int result;
56077
56078   {
56079     try {
56080       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
56081     } catch (std::out_of_range& e) {
56082       {
56083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56084       };
56085     } catch (std::exception& e) {
56086       {
56087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56088       };
56089     } catch (...) {
56090       {
56091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56092       };
56093     }
56094   }
56095   jresult = (int)result;
56096   return jresult;
56097 }
56098
56099
56100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
56101   int jresult ;
56102   int result;
56103
56104   {
56105     try {
56106       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
56107     } catch (std::out_of_range& e) {
56108       {
56109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56110       };
56111     } catch (std::exception& e) {
56112       {
56113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56114       };
56115     } catch (...) {
56116       {
56117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56118       };
56119     }
56120   }
56121   jresult = (int)result;
56122   return jresult;
56123 }
56124
56125
56126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
56127   int jresult ;
56128   int result;
56129
56130   {
56131     try {
56132       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
56133     } catch (std::out_of_range& e) {
56134       {
56135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56136       };
56137     } catch (std::exception& e) {
56138       {
56139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56140       };
56141     } catch (...) {
56142       {
56143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56144       };
56145     }
56146   }
56147   jresult = (int)result;
56148   return jresult;
56149 }
56150
56151
56152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
56153   int jresult ;
56154   int result;
56155
56156   {
56157     try {
56158       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
56159     } catch (std::out_of_range& e) {
56160       {
56161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56162       };
56163     } catch (std::exception& e) {
56164       {
56165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56166       };
56167     } catch (...) {
56168       {
56169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56170       };
56171     }
56172   }
56173   jresult = (int)result;
56174   return jresult;
56175 }
56176
56177
56178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
56179   int jresult ;
56180   int result;
56181
56182   {
56183     try {
56184       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
56185     } catch (std::out_of_range& e) {
56186       {
56187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56188       };
56189     } catch (std::exception& e) {
56190       {
56191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56192       };
56193     } catch (...) {
56194       {
56195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56196       };
56197     }
56198   }
56199   jresult = (int)result;
56200   return jresult;
56201 }
56202
56203
56204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
56205   int jresult ;
56206   int result;
56207
56208   {
56209     try {
56210       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
56211     } catch (std::out_of_range& e) {
56212       {
56213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56214       };
56215     } catch (std::exception& e) {
56216       {
56217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56218       };
56219     } catch (...) {
56220       {
56221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56222       };
56223     }
56224   }
56225   jresult = (int)result;
56226   return jresult;
56227 }
56228
56229
56230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
56231   int jresult ;
56232   int result;
56233
56234   {
56235     try {
56236       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
56237     } catch (std::out_of_range& e) {
56238       {
56239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56240       };
56241     } catch (std::exception& e) {
56242       {
56243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56244       };
56245     } catch (...) {
56246       {
56247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56248       };
56249     }
56250   }
56251   jresult = (int)result;
56252   return jresult;
56253 }
56254
56255
56256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
56257   int jresult ;
56258   int result;
56259
56260   {
56261     try {
56262       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
56263     } catch (std::out_of_range& e) {
56264       {
56265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56266       };
56267     } catch (std::exception& e) {
56268       {
56269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56270       };
56271     } catch (...) {
56272       {
56273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56274       };
56275     }
56276   }
56277   jresult = (int)result;
56278   return jresult;
56279 }
56280
56281
56282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56283   int jresult ;
56284   int result;
56285
56286   {
56287     try {
56288       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56289     } catch (std::out_of_range& e) {
56290       {
56291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56292       };
56293     } catch (std::exception& e) {
56294       {
56295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56296       };
56297     } catch (...) {
56298       {
56299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56300       };
56301     }
56302   }
56303   jresult = (int)result;
56304   return jresult;
56305 }
56306
56307
56308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56309   int jresult ;
56310   int result;
56311
56312   {
56313     try {
56314       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56315     } catch (std::out_of_range& e) {
56316       {
56317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56318       };
56319     } catch (std::exception& e) {
56320       {
56321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56322       };
56323     } catch (...) {
56324       {
56325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56326       };
56327     }
56328   }
56329   jresult = (int)result;
56330   return jresult;
56331 }
56332
56333
56334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
56335   int jresult ;
56336   int result;
56337
56338   {
56339     try {
56340       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
56341     } catch (std::out_of_range& e) {
56342       {
56343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56344       };
56345     } catch (std::exception& e) {
56346       {
56347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56348       };
56349     } catch (...) {
56350       {
56351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56352       };
56353     }
56354   }
56355   jresult = (int)result;
56356   return jresult;
56357 }
56358
56359
56360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56361   int jresult ;
56362   int result;
56363
56364   {
56365     try {
56366       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56367     } catch (std::out_of_range& e) {
56368       {
56369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56370       };
56371     } catch (std::exception& e) {
56372       {
56373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56374       };
56375     } catch (...) {
56376       {
56377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56378       };
56379     }
56380   }
56381   jresult = (int)result;
56382   return jresult;
56383 }
56384
56385
56386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56387   int jresult ;
56388   int result;
56389
56390   {
56391     try {
56392       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56393     } catch (std::out_of_range& e) {
56394       {
56395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56396       };
56397     } catch (std::exception& e) {
56398       {
56399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56400       };
56401     } catch (...) {
56402       {
56403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56404       };
56405     }
56406   }
56407   jresult = (int)result;
56408   return jresult;
56409 }
56410
56411
56412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56413   int jresult ;
56414   int result;
56415
56416   {
56417     try {
56418       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56419     } catch (std::out_of_range& e) {
56420       {
56421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56422       };
56423     } catch (std::exception& e) {
56424       {
56425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56426       };
56427     } catch (...) {
56428       {
56429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56430       };
56431     }
56432   }
56433   jresult = (int)result;
56434   return jresult;
56435 }
56436
56437
56438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56439   int jresult ;
56440   int result;
56441
56442   {
56443     try {
56444       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56445     } catch (std::out_of_range& e) {
56446       {
56447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56448       };
56449     } catch (std::exception& e) {
56450       {
56451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56452       };
56453     } catch (...) {
56454       {
56455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56456       };
56457     }
56458   }
56459   jresult = (int)result;
56460   return jresult;
56461 }
56462
56463
56464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56465   int jresult ;
56466   int result;
56467
56468   {
56469     try {
56470       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56471     } catch (std::out_of_range& e) {
56472       {
56473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56474       };
56475     } catch (std::exception& e) {
56476       {
56477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56478       };
56479     } catch (...) {
56480       {
56481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56482       };
56483     }
56484   }
56485   jresult = (int)result;
56486   return jresult;
56487 }
56488
56489
56490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56491   int jresult ;
56492   int result;
56493
56494   {
56495     try {
56496       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56497     } catch (std::out_of_range& e) {
56498       {
56499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56500       };
56501     } catch (std::exception& e) {
56502       {
56503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56504       };
56505     } catch (...) {
56506       {
56507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56508       };
56509     }
56510   }
56511   jresult = (int)result;
56512   return jresult;
56513 }
56514
56515
56516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56517   int jresult ;
56518   int result;
56519
56520   {
56521     try {
56522       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56523     } catch (std::out_of_range& e) {
56524       {
56525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56526       };
56527     } catch (std::exception& e) {
56528       {
56529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56530       };
56531     } catch (...) {
56532       {
56533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56534       };
56535     }
56536   }
56537   jresult = (int)result;
56538   return jresult;
56539 }
56540
56541
56542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56543   int jresult ;
56544   int result;
56545
56546   {
56547     try {
56548       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56549     } catch (std::out_of_range& e) {
56550       {
56551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56552       };
56553     } catch (std::exception& e) {
56554       {
56555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56556       };
56557     } catch (...) {
56558       {
56559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56560       };
56561     }
56562   }
56563   jresult = (int)result;
56564   return jresult;
56565 }
56566
56567
56568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56569   int jresult ;
56570   int result;
56571
56572   {
56573     try {
56574       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56575     } catch (std::out_of_range& e) {
56576       {
56577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56578       };
56579     } catch (std::exception& e) {
56580       {
56581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56582       };
56583     } catch (...) {
56584       {
56585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56586       };
56587     }
56588   }
56589   jresult = (int)result;
56590   return jresult;
56591 }
56592
56593
56594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56595   int jresult ;
56596   int result;
56597
56598   {
56599     try {
56600       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56601     } catch (std::out_of_range& e) {
56602       {
56603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56604       };
56605     } catch (std::exception& e) {
56606       {
56607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56608       };
56609     } catch (...) {
56610       {
56611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56612       };
56613     }
56614   }
56615   jresult = (int)result;
56616   return jresult;
56617 }
56618
56619
56620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56621   int jresult ;
56622   int result;
56623
56624   {
56625     try {
56626       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56627     } catch (std::out_of_range& e) {
56628       {
56629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56630       };
56631     } catch (std::exception& e) {
56632       {
56633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56634       };
56635     } catch (...) {
56636       {
56637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56638       };
56639     }
56640   }
56641   jresult = (int)result;
56642   return jresult;
56643 }
56644
56645
56646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56647   int jresult ;
56648   int result;
56649
56650   {
56651     try {
56652       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56653     } catch (std::out_of_range& e) {
56654       {
56655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56656       };
56657     } catch (std::exception& e) {
56658       {
56659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56660       };
56661     } catch (...) {
56662       {
56663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56664       };
56665     }
56666   }
56667   jresult = (int)result;
56668   return jresult;
56669 }
56670
56671
56672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56673   int jresult ;
56674   int result;
56675
56676   {
56677     try {
56678       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56679     } catch (std::out_of_range& e) {
56680       {
56681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56682       };
56683     } catch (std::exception& e) {
56684       {
56685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56686       };
56687     } catch (...) {
56688       {
56689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56690       };
56691     }
56692   }
56693   jresult = (int)result;
56694   return jresult;
56695 }
56696
56697
56698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56699   int jresult ;
56700   int result;
56701
56702   {
56703     try {
56704       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56705     } catch (std::out_of_range& e) {
56706       {
56707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56708       };
56709     } catch (std::exception& e) {
56710       {
56711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56712       };
56713     } catch (...) {
56714       {
56715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56716       };
56717     }
56718   }
56719   jresult = (int)result;
56720   return jresult;
56721 }
56722
56723
56724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56725   int jresult ;
56726   int result;
56727
56728   {
56729     try {
56730       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56731     } catch (std::out_of_range& e) {
56732       {
56733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56734       };
56735     } catch (std::exception& e) {
56736       {
56737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56738       };
56739     } catch (...) {
56740       {
56741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56742       };
56743     }
56744   }
56745   jresult = (int)result;
56746   return jresult;
56747 }
56748
56749
56750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56751   int jresult ;
56752   int result;
56753
56754   {
56755     try {
56756       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56757     } catch (std::out_of_range& e) {
56758       {
56759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56760       };
56761     } catch (std::exception& e) {
56762       {
56763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56764       };
56765     } catch (...) {
56766       {
56767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56768       };
56769     }
56770   }
56771   jresult = (int)result;
56772   return jresult;
56773 }
56774
56775
56776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56777   int jresult ;
56778   int result;
56779
56780   {
56781     try {
56782       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56783     } catch (std::out_of_range& e) {
56784       {
56785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56786       };
56787     } catch (std::exception& e) {
56788       {
56789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56790       };
56791     } catch (...) {
56792       {
56793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56794       };
56795     }
56796   }
56797   jresult = (int)result;
56798   return jresult;
56799 }
56800
56801
56802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56803   int jresult ;
56804   int result;
56805
56806   {
56807     try {
56808       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56809     } catch (std::out_of_range& e) {
56810       {
56811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56812       };
56813     } catch (std::exception& e) {
56814       {
56815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56816       };
56817     } catch (...) {
56818       {
56819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56820       };
56821     }
56822   }
56823   jresult = (int)result;
56824   return jresult;
56825 }
56826
56827
56828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56829   int jresult ;
56830   int result;
56831
56832   {
56833     try {
56834       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56835     } catch (std::out_of_range& e) {
56836       {
56837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56838       };
56839     } catch (std::exception& e) {
56840       {
56841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56842       };
56843     } catch (...) {
56844       {
56845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56846       };
56847     }
56848   }
56849   jresult = (int)result;
56850   return jresult;
56851 }
56852
56853
56854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56855   int jresult ;
56856   int result;
56857
56858   {
56859     try {
56860       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56861     } catch (std::out_of_range& e) {
56862       {
56863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56864       };
56865     } catch (std::exception& e) {
56866       {
56867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56868       };
56869     } catch (...) {
56870       {
56871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56872       };
56873     }
56874   }
56875   jresult = (int)result;
56876   return jresult;
56877 }
56878
56879
56880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56881   int jresult ;
56882   int result;
56883
56884   {
56885     try {
56886       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56887     } catch (std::out_of_range& e) {
56888       {
56889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56890       };
56891     } catch (std::exception& e) {
56892       {
56893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56894       };
56895     } catch (...) {
56896       {
56897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56898       };
56899     }
56900   }
56901   jresult = (int)result;
56902   return jresult;
56903 }
56904
56905
56906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56907   int jresult ;
56908   int result;
56909
56910   {
56911     try {
56912       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56913     } catch (std::out_of_range& e) {
56914       {
56915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56916       };
56917     } catch (std::exception& e) {
56918       {
56919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56920       };
56921     } catch (...) {
56922       {
56923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56924       };
56925     }
56926   }
56927   jresult = (int)result;
56928   return jresult;
56929 }
56930
56931
56932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56933   int jresult ;
56934   int result;
56935
56936   {
56937     try {
56938       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56939     } catch (std::out_of_range& e) {
56940       {
56941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56942       };
56943     } catch (std::exception& e) {
56944       {
56945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56946       };
56947     } catch (...) {
56948       {
56949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56950       };
56951     }
56952   }
56953   jresult = (int)result;
56954   return jresult;
56955 }
56956
56957
56958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56959   int jresult ;
56960   int result;
56961
56962   {
56963     try {
56964       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56965     } catch (std::out_of_range& e) {
56966       {
56967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56968       };
56969     } catch (std::exception& e) {
56970       {
56971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56972       };
56973     } catch (...) {
56974       {
56975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56976       };
56977     }
56978   }
56979   jresult = (int)result;
56980   return jresult;
56981 }
56982
56983
56984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56985   int jresult ;
56986   int result;
56987
56988   {
56989     try {
56990       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56991     } catch (std::out_of_range& e) {
56992       {
56993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56994       };
56995     } catch (std::exception& e) {
56996       {
56997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56998       };
56999     } catch (...) {
57000       {
57001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57002       };
57003     }
57004   }
57005   jresult = (int)result;
57006   return jresult;
57007 }
57008
57009
57010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57011   int jresult ;
57012   int result;
57013
57014   {
57015     try {
57016       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57017     } catch (std::out_of_range& e) {
57018       {
57019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57020       };
57021     } catch (std::exception& e) {
57022       {
57023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57024       };
57025     } catch (...) {
57026       {
57027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57028       };
57029     }
57030   }
57031   jresult = (int)result;
57032   return jresult;
57033 }
57034
57035
57036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57037   int jresult ;
57038   int result;
57039
57040   {
57041     try {
57042       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
57043     } catch (std::out_of_range& e) {
57044       {
57045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57046       };
57047     } catch (std::exception& e) {
57048       {
57049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57050       };
57051     } catch (...) {
57052       {
57053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57054       };
57055     }
57056   }
57057   jresult = (int)result;
57058   return jresult;
57059 }
57060
57061
57062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57063   int jresult ;
57064   int result;
57065
57066   {
57067     try {
57068       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57069     } catch (std::out_of_range& e) {
57070       {
57071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57072       };
57073     } catch (std::exception& e) {
57074       {
57075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57076       };
57077     } catch (...) {
57078       {
57079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57080       };
57081     }
57082   }
57083   jresult = (int)result;
57084   return jresult;
57085 }
57086
57087
57088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57089   int jresult ;
57090   int result;
57091
57092   {
57093     try {
57094       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57095     } catch (std::out_of_range& e) {
57096       {
57097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57098       };
57099     } catch (std::exception& e) {
57100       {
57101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57102       };
57103     } catch (...) {
57104       {
57105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57106       };
57107     }
57108   }
57109   jresult = (int)result;
57110   return jresult;
57111 }
57112
57113
57114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57115   int jresult ;
57116   int result;
57117
57118   {
57119     try {
57120       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
57121     } catch (std::out_of_range& e) {
57122       {
57123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57124       };
57125     } catch (std::exception& e) {
57126       {
57127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57128       };
57129     } catch (...) {
57130       {
57131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57132       };
57133     }
57134   }
57135   jresult = (int)result;
57136   return jresult;
57137 }
57138
57139
57140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57141   int jresult ;
57142   int result;
57143
57144   {
57145     try {
57146       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57147     } catch (std::out_of_range& e) {
57148       {
57149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57150       };
57151     } catch (std::exception& e) {
57152       {
57153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57154       };
57155     } catch (...) {
57156       {
57157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57158       };
57159     }
57160   }
57161   jresult = (int)result;
57162   return jresult;
57163 }
57164
57165
57166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57167   int jresult ;
57168   int result;
57169
57170   {
57171     try {
57172       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57173     } catch (std::out_of_range& e) {
57174       {
57175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57176       };
57177     } catch (std::exception& e) {
57178       {
57179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57180       };
57181     } catch (...) {
57182       {
57183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57184       };
57185     }
57186   }
57187   jresult = (int)result;
57188   return jresult;
57189 }
57190
57191
57192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57193   int jresult ;
57194   int result;
57195
57196   {
57197     try {
57198       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57199     } catch (std::out_of_range& e) {
57200       {
57201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57202       };
57203     } catch (std::exception& e) {
57204       {
57205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57206       };
57207     } catch (...) {
57208       {
57209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57210       };
57211     }
57212   }
57213   jresult = (int)result;
57214   return jresult;
57215 }
57216
57217
57218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57219   int jresult ;
57220   int result;
57221
57222   {
57223     try {
57224       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57225     } catch (std::out_of_range& e) {
57226       {
57227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57228       };
57229     } catch (std::exception& e) {
57230       {
57231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57232       };
57233     } catch (...) {
57234       {
57235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57236       };
57237     }
57238   }
57239   jresult = (int)result;
57240   return jresult;
57241 }
57242
57243
57244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57245   int jresult ;
57246   int result;
57247
57248   {
57249     try {
57250       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57251     } catch (std::out_of_range& e) {
57252       {
57253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57254       };
57255     } catch (std::exception& e) {
57256       {
57257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57258       };
57259     } catch (...) {
57260       {
57261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57262       };
57263     }
57264   }
57265   jresult = (int)result;
57266   return jresult;
57267 }
57268
57269
57270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57271   int jresult ;
57272   int result;
57273
57274   {
57275     try {
57276       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57277     } catch (std::out_of_range& e) {
57278       {
57279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57280       };
57281     } catch (std::exception& e) {
57282       {
57283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57284       };
57285     } catch (...) {
57286       {
57287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57288       };
57289     }
57290   }
57291   jresult = (int)result;
57292   return jresult;
57293 }
57294
57295
57296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57297   int jresult ;
57298   int result;
57299
57300   {
57301     try {
57302       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57303     } catch (std::out_of_range& e) {
57304       {
57305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57306       };
57307     } catch (std::exception& e) {
57308       {
57309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57310       };
57311     } catch (...) {
57312       {
57313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57314       };
57315     }
57316   }
57317   jresult = (int)result;
57318   return jresult;
57319 }
57320
57321
57322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57323   int jresult ;
57324   int result;
57325
57326   {
57327     try {
57328       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57329     } catch (std::out_of_range& e) {
57330       {
57331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57332       };
57333     } catch (std::exception& e) {
57334       {
57335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57336       };
57337     } catch (...) {
57338       {
57339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57340       };
57341     }
57342   }
57343   jresult = (int)result;
57344   return jresult;
57345 }
57346
57347
57348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57349   int jresult ;
57350   int result;
57351
57352   {
57353     try {
57354       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57355     } catch (std::out_of_range& e) {
57356       {
57357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57358       };
57359     } catch (std::exception& e) {
57360       {
57361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57362       };
57363     } catch (...) {
57364       {
57365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57366       };
57367     }
57368   }
57369   jresult = (int)result;
57370   return jresult;
57371 }
57372
57373
57374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57375   int jresult ;
57376   int result;
57377
57378   {
57379     try {
57380       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57381     } catch (std::out_of_range& e) {
57382       {
57383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57384       };
57385     } catch (std::exception& e) {
57386       {
57387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57388       };
57389     } catch (...) {
57390       {
57391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57392       };
57393     }
57394   }
57395   jresult = (int)result;
57396   return jresult;
57397 }
57398
57399
57400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57401   void * jresult ;
57402   Dali::Toolkit::Builder *result = 0 ;
57403
57404   {
57405     try {
57406       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57407     } catch (std::out_of_range& e) {
57408       {
57409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57410       };
57411     } catch (std::exception& e) {
57412       {
57413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57414       };
57415     } catch (...) {
57416       {
57417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57418       };
57419     }
57420   }
57421   jresult = (void *)result;
57422   return jresult;
57423 }
57424
57425
57426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57427   void * jresult ;
57428   Dali::Toolkit::Builder result;
57429
57430   {
57431     try {
57432       result = Dali::Toolkit::Builder::New();
57433     } catch (std::out_of_range& e) {
57434       {
57435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57436       };
57437     } catch (std::exception& e) {
57438       {
57439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57440       };
57441     } catch (...) {
57442       {
57443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57444       };
57445     }
57446   }
57447   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57448   return jresult;
57449 }
57450
57451
57452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57453   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57454
57455   arg1 = (Dali::Toolkit::Builder *)jarg1;
57456   {
57457     try {
57458       delete arg1;
57459     } catch (std::out_of_range& e) {
57460       {
57461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57462       };
57463     } catch (std::exception& e) {
57464       {
57465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57466       };
57467     } catch (...) {
57468       {
57469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57470       };
57471     }
57472   }
57473 }
57474
57475
57476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57477   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57478   std::string *arg2 = 0 ;
57479   Dali::Toolkit::Builder::UIFormat arg3 ;
57480
57481   arg1 = (Dali::Toolkit::Builder *)jarg1;
57482   if (!jarg2) {
57483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57484     return ;
57485   }
57486   std::string arg2_str(jarg2);
57487   arg2 = &arg2_str;
57488   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57489   {
57490     try {
57491       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57492     } catch (std::out_of_range& e) {
57493       {
57494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57495       };
57496     } catch (std::exception& e) {
57497       {
57498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57499       };
57500     } catch (...) {
57501       {
57502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57503       };
57504     }
57505   }
57506
57507   //argout typemap for const std::string&
57508
57509 }
57510
57511
57512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57513   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57514   std::string *arg2 = 0 ;
57515
57516   arg1 = (Dali::Toolkit::Builder *)jarg1;
57517   if (!jarg2) {
57518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57519     return ;
57520   }
57521   std::string arg2_str(jarg2);
57522   arg2 = &arg2_str;
57523   {
57524     try {
57525       (arg1)->LoadFromString((std::string const &)*arg2);
57526     } catch (std::out_of_range& e) {
57527       {
57528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57529       };
57530     } catch (std::exception& e) {
57531       {
57532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57533       };
57534     } catch (...) {
57535       {
57536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57537       };
57538     }
57539   }
57540
57541   //argout typemap for const std::string&
57542
57543 }
57544
57545
57546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57547   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57548   Dali::Property::Map *arg2 = 0 ;
57549
57550   arg1 = (Dali::Toolkit::Builder *)jarg1;
57551   arg2 = (Dali::Property::Map *)jarg2;
57552   if (!arg2) {
57553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57554     return ;
57555   }
57556   {
57557     try {
57558       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57559     } catch (std::out_of_range& e) {
57560       {
57561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57562       };
57563     } catch (std::exception& e) {
57564       {
57565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57566       };
57567     } catch (...) {
57568       {
57569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57570       };
57571     }
57572   }
57573 }
57574
57575
57576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57577   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57578   std::string *arg2 = 0 ;
57579   Dali::Property::Value *arg3 = 0 ;
57580
57581   arg1 = (Dali::Toolkit::Builder *)jarg1;
57582   if (!jarg2) {
57583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57584     return ;
57585   }
57586   std::string arg2_str(jarg2);
57587   arg2 = &arg2_str;
57588   arg3 = (Dali::Property::Value *)jarg3;
57589   if (!arg3) {
57590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57591     return ;
57592   }
57593   {
57594     try {
57595       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57596     } catch (std::out_of_range& e) {
57597       {
57598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57599       };
57600     } catch (std::exception& e) {
57601       {
57602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57603       };
57604     } catch (...) {
57605       {
57606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57607       };
57608     }
57609   }
57610
57611   //argout typemap for const std::string&
57612
57613 }
57614
57615
57616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57617   void * jresult ;
57618   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57619   Dali::Property::Map *result = 0 ;
57620
57621   arg1 = (Dali::Toolkit::Builder *)jarg1;
57622   {
57623     try {
57624       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57625     } catch (std::out_of_range& e) {
57626       {
57627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57628       };
57629     } catch (std::exception& e) {
57630       {
57631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57632       };
57633     } catch (...) {
57634       {
57635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57636       };
57637     }
57638   }
57639   jresult = (void *)result;
57640   return jresult;
57641 }
57642
57643
57644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57645   void * jresult ;
57646   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57647   std::string *arg2 = 0 ;
57648   Dali::Property::Value *result = 0 ;
57649
57650   arg1 = (Dali::Toolkit::Builder *)jarg1;
57651   if (!jarg2) {
57652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57653     return 0;
57654   }
57655   std::string arg2_str(jarg2);
57656   arg2 = &arg2_str;
57657   {
57658     try {
57659       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57660     } catch (std::out_of_range& e) {
57661       {
57662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57663       };
57664     } catch (std::exception& e) {
57665       {
57666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57667       };
57668     } catch (...) {
57669       {
57670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57671       };
57672     }
57673   }
57674   jresult = (void *)result;
57675
57676   //argout typemap for const std::string&
57677
57678   return jresult;
57679 }
57680
57681
57682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57683   void * jresult ;
57684   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57685   std::string *arg2 = 0 ;
57686   Dali::Animation result;
57687
57688   arg1 = (Dali::Toolkit::Builder *)jarg1;
57689   if (!jarg2) {
57690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57691     return 0;
57692   }
57693   std::string arg2_str(jarg2);
57694   arg2 = &arg2_str;
57695   {
57696     try {
57697       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57698     } catch (std::out_of_range& e) {
57699       {
57700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57701       };
57702     } catch (std::exception& e) {
57703       {
57704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57705       };
57706     } catch (...) {
57707       {
57708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57709       };
57710     }
57711   }
57712   jresult = new Dali::Animation((const Dali::Animation &)result);
57713
57714   //argout typemap for const std::string&
57715
57716   return jresult;
57717 }
57718
57719
57720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57721   void * jresult ;
57722   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57723   std::string *arg2 = 0 ;
57724   Dali::Property::Map *arg3 = 0 ;
57725   Dali::Animation result;
57726
57727   arg1 = (Dali::Toolkit::Builder *)jarg1;
57728   if (!jarg2) {
57729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57730     return 0;
57731   }
57732   std::string arg2_str(jarg2);
57733   arg2 = &arg2_str;
57734   arg3 = (Dali::Property::Map *)jarg3;
57735   if (!arg3) {
57736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57737     return 0;
57738   }
57739   {
57740     try {
57741       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57742     } catch (std::out_of_range& e) {
57743       {
57744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57745       };
57746     } catch (std::exception& e) {
57747       {
57748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57749       };
57750     } catch (...) {
57751       {
57752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57753       };
57754     }
57755   }
57756   jresult = new Dali::Animation((const Dali::Animation &)result);
57757
57758   //argout typemap for const std::string&
57759
57760   return jresult;
57761 }
57762
57763
57764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57765   void * jresult ;
57766   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57767   std::string *arg2 = 0 ;
57768   Dali::Actor arg3 ;
57769   Dali::Actor *argp3 ;
57770   Dali::Animation result;
57771
57772   arg1 = (Dali::Toolkit::Builder *)jarg1;
57773   if (!jarg2) {
57774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57775     return 0;
57776   }
57777   std::string arg2_str(jarg2);
57778   arg2 = &arg2_str;
57779   argp3 = (Dali::Actor *)jarg3;
57780   if (!argp3) {
57781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57782     return 0;
57783   }
57784   arg3 = *argp3;
57785   {
57786     try {
57787       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57788     } catch (std::out_of_range& e) {
57789       {
57790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57791       };
57792     } catch (std::exception& e) {
57793       {
57794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57795       };
57796     } catch (...) {
57797       {
57798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57799       };
57800     }
57801   }
57802   jresult = new Dali::Animation((const Dali::Animation &)result);
57803
57804   //argout typemap for const std::string&
57805
57806   return jresult;
57807 }
57808
57809
57810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57811   void * jresult ;
57812   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57813   std::string *arg2 = 0 ;
57814   Dali::Property::Map *arg3 = 0 ;
57815   Dali::Actor arg4 ;
57816   Dali::Actor *argp4 ;
57817   Dali::Animation result;
57818
57819   arg1 = (Dali::Toolkit::Builder *)jarg1;
57820   if (!jarg2) {
57821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57822     return 0;
57823   }
57824   std::string arg2_str(jarg2);
57825   arg2 = &arg2_str;
57826   arg3 = (Dali::Property::Map *)jarg3;
57827   if (!arg3) {
57828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57829     return 0;
57830   }
57831   argp4 = (Dali::Actor *)jarg4;
57832   if (!argp4) {
57833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57834     return 0;
57835   }
57836   arg4 = *argp4;
57837   {
57838     try {
57839       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57840     } catch (std::out_of_range& e) {
57841       {
57842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57843       };
57844     } catch (std::exception& e) {
57845       {
57846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57847       };
57848     } catch (...) {
57849       {
57850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57851       };
57852     }
57853   }
57854   jresult = new Dali::Animation((const Dali::Animation &)result);
57855
57856   //argout typemap for const std::string&
57857
57858   return jresult;
57859 }
57860
57861
57862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57863   void * jresult ;
57864   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57865   std::string *arg2 = 0 ;
57866   Dali::BaseHandle result;
57867
57868   arg1 = (Dali::Toolkit::Builder *)jarg1;
57869   if (!jarg2) {
57870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57871     return 0;
57872   }
57873   std::string arg2_str(jarg2);
57874   arg2 = &arg2_str;
57875   {
57876     try {
57877       result = (arg1)->Create((std::string const &)*arg2);
57878     } catch (std::out_of_range& e) {
57879       {
57880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57881       };
57882     } catch (std::exception& e) {
57883       {
57884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57885       };
57886     } catch (...) {
57887       {
57888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57889       };
57890     }
57891   }
57892   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57893
57894   //argout typemap for const std::string&
57895
57896   return jresult;
57897 }
57898
57899
57900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57901   void * jresult ;
57902   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57903   std::string *arg2 = 0 ;
57904   Dali::Property::Map *arg3 = 0 ;
57905   Dali::BaseHandle result;
57906
57907   arg1 = (Dali::Toolkit::Builder *)jarg1;
57908   if (!jarg2) {
57909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57910     return 0;
57911   }
57912   std::string arg2_str(jarg2);
57913   arg2 = &arg2_str;
57914   arg3 = (Dali::Property::Map *)jarg3;
57915   if (!arg3) {
57916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57917     return 0;
57918   }
57919   {
57920     try {
57921       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57922     } catch (std::out_of_range& e) {
57923       {
57924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57925       };
57926     } catch (std::exception& e) {
57927       {
57928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57929       };
57930     } catch (...) {
57931       {
57932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57933       };
57934     }
57935   }
57936   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57937
57938   //argout typemap for const std::string&
57939
57940   return jresult;
57941 }
57942
57943
57944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57945   void * jresult ;
57946   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57947   std::string *arg2 = 0 ;
57948   Dali::BaseHandle result;
57949
57950   arg1 = (Dali::Toolkit::Builder *)jarg1;
57951   if (!jarg2) {
57952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57953     return 0;
57954   }
57955   std::string arg2_str(jarg2);
57956   arg2 = &arg2_str;
57957   {
57958     try {
57959       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57960     } catch (std::out_of_range& e) {
57961       {
57962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57963       };
57964     } catch (std::exception& e) {
57965       {
57966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57967       };
57968     } catch (...) {
57969       {
57970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57971       };
57972     }
57973   }
57974   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57975
57976   //argout typemap for const std::string&
57977
57978   return jresult;
57979 }
57980
57981
57982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57983   unsigned int jresult ;
57984   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57985   std::string *arg2 = 0 ;
57986   Dali::Handle *arg3 = 0 ;
57987   bool result;
57988
57989   arg1 = (Dali::Toolkit::Builder *)jarg1;
57990   if (!jarg2) {
57991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57992     return 0;
57993   }
57994   std::string arg2_str(jarg2);
57995   arg2 = &arg2_str;
57996   arg3 = (Dali::Handle *)jarg3;
57997   if (!arg3) {
57998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57999     return 0;
58000   }
58001   {
58002     try {
58003       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58004     } catch (std::out_of_range& e) {
58005       {
58006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58007       };
58008     } catch (std::exception& e) {
58009       {
58010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58011       };
58012     } catch (...) {
58013       {
58014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58015       };
58016     }
58017   }
58018   jresult = result;
58019
58020   //argout typemap for const std::string&
58021
58022   return jresult;
58023 }
58024
58025
58026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58027   unsigned int jresult ;
58028   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58029   Dali::Handle *arg2 = 0 ;
58030   std::string *arg3 = 0 ;
58031   bool result;
58032
58033   arg1 = (Dali::Toolkit::Builder *)jarg1;
58034   arg2 = (Dali::Handle *)jarg2;
58035   if (!arg2) {
58036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58037     return 0;
58038   }
58039   if (!jarg3) {
58040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58041     return 0;
58042   }
58043   std::string arg3_str(jarg3);
58044   arg3 = &arg3_str;
58045   {
58046     try {
58047       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58048     } catch (std::out_of_range& e) {
58049       {
58050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58051       };
58052     } catch (std::exception& e) {
58053       {
58054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58055       };
58056     } catch (...) {
58057       {
58058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58059       };
58060     }
58061   }
58062   jresult = result;
58063
58064   //argout typemap for const std::string&
58065
58066   return jresult;
58067 }
58068
58069
58070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58071   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58072   Dali::Actor arg2 ;
58073   Dali::Actor *argp2 ;
58074
58075   arg1 = (Dali::Toolkit::Builder *)jarg1;
58076   argp2 = (Dali::Actor *)jarg2;
58077   if (!argp2) {
58078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58079     return ;
58080   }
58081   arg2 = *argp2;
58082   {
58083     try {
58084       (arg1)->AddActors(arg2);
58085     } catch (std::out_of_range& e) {
58086       {
58087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58088       };
58089     } catch (std::exception& e) {
58090       {
58091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58092       };
58093     } catch (...) {
58094       {
58095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58096       };
58097     }
58098   }
58099 }
58100
58101
58102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58103   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58104   std::string *arg2 = 0 ;
58105   Dali::Actor arg3 ;
58106   Dali::Actor *argp3 ;
58107
58108   arg1 = (Dali::Toolkit::Builder *)jarg1;
58109   if (!jarg2) {
58110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58111     return ;
58112   }
58113   std::string arg2_str(jarg2);
58114   arg2 = &arg2_str;
58115   argp3 = (Dali::Actor *)jarg3;
58116   if (!argp3) {
58117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58118     return ;
58119   }
58120   arg3 = *argp3;
58121   {
58122     try {
58123       (arg1)->AddActors((std::string const &)*arg2,arg3);
58124     } catch (std::out_of_range& e) {
58125       {
58126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58127       };
58128     } catch (std::exception& e) {
58129       {
58130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58131       };
58132     } catch (...) {
58133       {
58134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58135       };
58136     }
58137   }
58138
58139   //argout typemap for const std::string&
58140
58141 }
58142
58143
58144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58145   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58146   std::string *arg2 = 0 ;
58147
58148   arg1 = (Dali::Toolkit::Builder *)jarg1;
58149   if (!jarg2) {
58150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58151     return ;
58152   }
58153   std::string arg2_str(jarg2);
58154   arg2 = &arg2_str;
58155   {
58156     try {
58157       (arg1)->CreateRenderTask((std::string const &)*arg2);
58158     } catch (std::out_of_range& e) {
58159       {
58160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58161       };
58162     } catch (std::exception& e) {
58163       {
58164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58165       };
58166     } catch (...) {
58167       {
58168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58169       };
58170     }
58171   }
58172
58173   //argout typemap for const std::string&
58174
58175 }
58176
58177
58178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
58179   void * jresult ;
58180   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58181   std::string *arg2 = 0 ;
58182   Dali::FrameBufferImage result;
58183
58184   arg1 = (Dali::Toolkit::Builder *)jarg1;
58185   if (!jarg2) {
58186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58187     return 0;
58188   }
58189   std::string arg2_str(jarg2);
58190   arg2 = &arg2_str;
58191   {
58192     try {
58193       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
58194     } catch (std::out_of_range& e) {
58195       {
58196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58197       };
58198     } catch (std::exception& e) {
58199       {
58200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58201       };
58202     } catch (...) {
58203       {
58204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58205       };
58206     }
58207   }
58208   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
58209
58210   //argout typemap for const std::string&
58211
58212   return jresult;
58213 }
58214
58215
58216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58217   void * jresult ;
58218   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58219   std::string *arg2 = 0 ;
58220   Dali::Path result;
58221
58222   arg1 = (Dali::Toolkit::Builder *)jarg1;
58223   if (!jarg2) {
58224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58225     return 0;
58226   }
58227   std::string arg2_str(jarg2);
58228   arg2 = &arg2_str;
58229   {
58230     try {
58231       result = (arg1)->GetPath((std::string const &)*arg2);
58232     } catch (std::out_of_range& e) {
58233       {
58234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58235       };
58236     } catch (std::exception& e) {
58237       {
58238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58239       };
58240     } catch (...) {
58241       {
58242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58243       };
58244     }
58245   }
58246   jresult = new Dali::Path((const Dali::Path &)result);
58247
58248   //argout typemap for const std::string&
58249
58250   return jresult;
58251 }
58252
58253
58254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58255   void * jresult ;
58256   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58257   std::string *arg2 = 0 ;
58258   Dali::PathConstrainer result;
58259
58260   arg1 = (Dali::Toolkit::Builder *)jarg1;
58261   if (!jarg2) {
58262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58263     return 0;
58264   }
58265   std::string arg2_str(jarg2);
58266   arg2 = &arg2_str;
58267   {
58268     try {
58269       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58270     } catch (std::out_of_range& e) {
58271       {
58272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58273       };
58274     } catch (std::exception& e) {
58275       {
58276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58277       };
58278     } catch (...) {
58279       {
58280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58281       };
58282     }
58283   }
58284   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58285
58286   //argout typemap for const std::string&
58287
58288   return jresult;
58289 }
58290
58291
58292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58293   void * jresult ;
58294   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58295   std::string *arg2 = 0 ;
58296   Dali::LinearConstrainer result;
58297
58298   arg1 = (Dali::Toolkit::Builder *)jarg1;
58299   if (!jarg2) {
58300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58301     return 0;
58302   }
58303   std::string arg2_str(jarg2);
58304   arg2 = &arg2_str;
58305   {
58306     try {
58307       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58308     } catch (std::out_of_range& e) {
58309       {
58310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58311       };
58312     } catch (std::exception& e) {
58313       {
58314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58315       };
58316     } catch (...) {
58317       {
58318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58319       };
58320     }
58321   }
58322   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58323
58324   //argout typemap for const std::string&
58325
58326   return jresult;
58327 }
58328
58329
58330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58331   void * jresult ;
58332   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58333   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58334
58335   arg1 = (Dali::Toolkit::Builder *)jarg1;
58336   {
58337     try {
58338       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58339     } catch (std::out_of_range& e) {
58340       {
58341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58342       };
58343     } catch (std::exception& e) {
58344       {
58345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58346       };
58347     } catch (...) {
58348       {
58349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58350       };
58351     }
58352   }
58353   jresult = (void *)result;
58354   return jresult;
58355 }
58356
58357
58358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58359   void * jresult ;
58360   Dali::Toolkit::TransitionData *result = 0 ;
58361
58362   {
58363     try {
58364       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58365     } catch (std::out_of_range& e) {
58366       {
58367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58368       };
58369     } catch (std::exception& e) {
58370       {
58371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58372       };
58373     } catch (...) {
58374       {
58375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58376       };
58377     }
58378   }
58379   jresult = (void *)result;
58380   return jresult;
58381 }
58382
58383
58384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58385   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58386
58387   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58388   {
58389     try {
58390       delete arg1;
58391     } catch (std::out_of_range& e) {
58392       {
58393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58394       };
58395     } catch (std::exception& e) {
58396       {
58397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58398       };
58399     } catch (...) {
58400       {
58401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58402       };
58403     }
58404   }
58405 }
58406
58407
58408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58409   void * jresult ;
58410   Dali::Property::Map *arg1 = 0 ;
58411   Dali::Toolkit::TransitionData result;
58412
58413   arg1 = (Dali::Property::Map *)jarg1;
58414   if (!arg1) {
58415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58416     return 0;
58417   }
58418   {
58419     try {
58420       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58421     } catch (std::out_of_range& e) {
58422       {
58423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58424       };
58425     } catch (std::exception& e) {
58426       {
58427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58428       };
58429     } catch (...) {
58430       {
58431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58432       };
58433     }
58434   }
58435   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58436   return jresult;
58437 }
58438
58439
58440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58441   void * jresult ;
58442   Dali::Property::Array *arg1 = 0 ;
58443   Dali::Toolkit::TransitionData result;
58444
58445   arg1 = (Dali::Property::Array *)jarg1;
58446   if (!arg1) {
58447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58448     return 0;
58449   }
58450   {
58451     try {
58452       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58453     } catch (std::out_of_range& e) {
58454       {
58455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58456       };
58457     } catch (std::exception& e) {
58458       {
58459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58460       };
58461     } catch (...) {
58462       {
58463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58464       };
58465     }
58466   }
58467   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58468   return jresult;
58469 }
58470
58471
58472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58473   void * jresult ;
58474   Dali::BaseHandle arg1 ;
58475   Dali::BaseHandle *argp1 ;
58476   Dali::Toolkit::TransitionData result;
58477
58478   argp1 = (Dali::BaseHandle *)jarg1;
58479   if (!argp1) {
58480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58481     return 0;
58482   }
58483   arg1 = *argp1;
58484   {
58485     try {
58486       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58487     } catch (std::out_of_range& e) {
58488       {
58489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58490       };
58491     } catch (std::exception& e) {
58492       {
58493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58494       };
58495     } catch (...) {
58496       {
58497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58498       };
58499     }
58500   }
58501   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58502   return jresult;
58503 }
58504
58505
58506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58507   void * jresult ;
58508   Dali::Toolkit::TransitionData *arg1 = 0 ;
58509   Dali::Toolkit::TransitionData *result = 0 ;
58510
58511   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58512   if (!arg1) {
58513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58514     return 0;
58515   }
58516   {
58517     try {
58518       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58519     } catch (std::out_of_range& e) {
58520       {
58521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58522       };
58523     } catch (std::exception& e) {
58524       {
58525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58526       };
58527     } catch (...) {
58528       {
58529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58530       };
58531     }
58532   }
58533   jresult = (void *)result;
58534   return jresult;
58535 }
58536
58537
58538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58539   void * jresult ;
58540   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58541   Dali::Toolkit::TransitionData *arg2 = 0 ;
58542   Dali::Toolkit::TransitionData *result = 0 ;
58543
58544   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58545   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58546   if (!arg2) {
58547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58548     return 0;
58549   }
58550   {
58551     try {
58552       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58553     } catch (std::out_of_range& e) {
58554       {
58555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58556       };
58557     } catch (std::exception& e) {
58558       {
58559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58560       };
58561     } catch (...) {
58562       {
58563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58564       };
58565     }
58566   }
58567   jresult = (void *)result;
58568   return jresult;
58569 }
58570
58571
58572 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58573   unsigned long jresult ;
58574   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58575   size_t result;
58576
58577   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58578   {
58579     try {
58580       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58581     } catch (std::out_of_range& e) {
58582       {
58583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58584       };
58585     } catch (std::exception& e) {
58586       {
58587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58588       };
58589     } catch (...) {
58590       {
58591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58592       };
58593     }
58594   }
58595   jresult = (unsigned long)result;
58596   return jresult;
58597 }
58598
58599
58600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58601   void * jresult ;
58602   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58603   size_t arg2 ;
58604   Dali::Property::Map result;
58605
58606   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58607   arg2 = (size_t)jarg2;
58608   {
58609     try {
58610       result = (arg1)->GetAnimatorAt(arg2);
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 = new Dali::Property::Map((const Dali::Property::Map &)result);
58626   return jresult;
58627 }
58628
58629
58630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
58631   void * jresult ;
58632   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
58633   Dali::Toolkit::TransitionData *result = 0 ;
58634
58635   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
58636   {
58637     try {
58638       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
58639     } catch (std::out_of_range& e) {
58640       {
58641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58642       };
58643     } catch (std::exception& e) {
58644       {
58645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58646       };
58647     } catch (...) {
58648       {
58649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58650       };
58651     }
58652   }
58653   jresult = (void *)result;
58654   return jresult;
58655 }
58656
58657
58658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58659   int jresult ;
58660   int result;
58661
58662   {
58663     try {
58664       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58665     } catch (std::out_of_range& e) {
58666       {
58667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58668       };
58669     } catch (std::exception& e) {
58670       {
58671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58672       };
58673     } catch (...) {
58674       {
58675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58676       };
58677     }
58678   }
58679   jresult = (int)result;
58680   return jresult;
58681 }
58682
58683
58684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58685   int jresult ;
58686   int result;
58687
58688   {
58689     try {
58690       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58691     } catch (std::out_of_range& e) {
58692       {
58693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58694       };
58695     } catch (std::exception& e) {
58696       {
58697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58698       };
58699     } catch (...) {
58700       {
58701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58702       };
58703     }
58704   }
58705   jresult = (int)result;
58706   return jresult;
58707 }
58708
58709
58710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58711   int jresult ;
58712   int result;
58713
58714   {
58715     try {
58716       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58717     } catch (std::out_of_range& e) {
58718       {
58719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58720       };
58721     } catch (std::exception& e) {
58722       {
58723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58724       };
58725     } catch (...) {
58726       {
58727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58728       };
58729     }
58730   }
58731   jresult = (int)result;
58732   return jresult;
58733 }
58734
58735
58736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58737   int jresult ;
58738   int result;
58739
58740   {
58741     try {
58742       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58743     } catch (std::out_of_range& e) {
58744       {
58745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58746       };
58747     } catch (std::exception& e) {
58748       {
58749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58750       };
58751     } catch (...) {
58752       {
58753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58754       };
58755     }
58756   }
58757   jresult = (int)result;
58758   return jresult;
58759 }
58760
58761
58762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58763   int jresult ;
58764   int result;
58765
58766   {
58767     try {
58768       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58769     } catch (std::out_of_range& e) {
58770       {
58771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58772       };
58773     } catch (std::exception& e) {
58774       {
58775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58776       };
58777     } catch (...) {
58778       {
58779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58780       };
58781     }
58782   }
58783   jresult = (int)result;
58784   return jresult;
58785 }
58786
58787
58788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58789   int jresult ;
58790   int result;
58791
58792   {
58793     try {
58794       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58795     } catch (std::out_of_range& e) {
58796       {
58797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58798       };
58799     } catch (std::exception& e) {
58800       {
58801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58802       };
58803     } catch (...) {
58804       {
58805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58806       };
58807     }
58808   }
58809   jresult = (int)result;
58810   return jresult;
58811 }
58812
58813
58814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58815   int jresult ;
58816   int result;
58817
58818   {
58819     try {
58820       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58821     } catch (std::out_of_range& e) {
58822       {
58823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58824       };
58825     } catch (std::exception& e) {
58826       {
58827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58828       };
58829     } catch (...) {
58830       {
58831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58832       };
58833     }
58834   }
58835   jresult = (int)result;
58836   return jresult;
58837 }
58838
58839
58840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58841   int jresult ;
58842   int result;
58843
58844   {
58845     try {
58846       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58847     } catch (std::out_of_range& e) {
58848       {
58849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58850       };
58851     } catch (std::exception& e) {
58852       {
58853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58854       };
58855     } catch (...) {
58856       {
58857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58858       };
58859     }
58860   }
58861   jresult = (int)result;
58862   return jresult;
58863 }
58864
58865
58866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58867   int jresult ;
58868   int result;
58869
58870   {
58871     try {
58872       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58873     } catch (std::out_of_range& e) {
58874       {
58875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58876       };
58877     } catch (std::exception& e) {
58878       {
58879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58880       };
58881     } catch (...) {
58882       {
58883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58884       };
58885     }
58886   }
58887   jresult = (int)result;
58888   return jresult;
58889 }
58890
58891
58892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58893   int jresult ;
58894   int result;
58895
58896   {
58897     try {
58898       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58899     } catch (std::out_of_range& e) {
58900       {
58901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58902       };
58903     } catch (std::exception& e) {
58904       {
58905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58906       };
58907     } catch (...) {
58908       {
58909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58910       };
58911     }
58912   }
58913   jresult = (int)result;
58914   return jresult;
58915 }
58916
58917
58918 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58919   int jresult ;
58920   int result;
58921
58922   {
58923     try {
58924       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58925     } catch (std::out_of_range& e) {
58926       {
58927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58928       };
58929     } catch (std::exception& e) {
58930       {
58931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58932       };
58933     } catch (...) {
58934       {
58935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58936       };
58937     }
58938   }
58939   jresult = (int)result;
58940   return jresult;
58941 }
58942
58943
58944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58945   int jresult ;
58946   int result;
58947
58948   {
58949     try {
58950       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58951     } catch (std::out_of_range& e) {
58952       {
58953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58954       };
58955     } catch (std::exception& e) {
58956       {
58957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58958       };
58959     } catch (...) {
58960       {
58961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58962       };
58963     }
58964   }
58965   jresult = (int)result;
58966   return jresult;
58967 }
58968
58969
58970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58971   int jresult ;
58972   int result;
58973
58974   {
58975     try {
58976       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58977     } catch (std::out_of_range& e) {
58978       {
58979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58980       };
58981     } catch (std::exception& e) {
58982       {
58983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58984       };
58985     } catch (...) {
58986       {
58987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58988       };
58989     }
58990   }
58991   jresult = (int)result;
58992   return jresult;
58993 }
58994
58995
58996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58997   int jresult ;
58998   int result;
58999
59000   {
59001     try {
59002       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
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 = (int)result;
59018   return jresult;
59019 }
59020
59021
59022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59023   void * jresult ;
59024   Dali::Toolkit::Control result;
59025
59026   {
59027     try {
59028       result = Dali::Toolkit::Internal::Control::New();
59029     } catch (std::out_of_range& e) {
59030       {
59031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59032       };
59033     } catch (std::exception& e) {
59034       {
59035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59036       };
59037     } catch (...) {
59038       {
59039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59040       };
59041     }
59042   }
59043   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59044   return jresult;
59045 }
59046
59047
59048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59050   std::string *arg2 = 0 ;
59051
59052   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59053   if (!jarg2) {
59054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59055     return ;
59056   }
59057   std::string arg2_str(jarg2);
59058   arg2 = &arg2_str;
59059   {
59060     try {
59061       (arg1)->SetStyleName((std::string const &)*arg2);
59062     } catch (std::out_of_range& e) {
59063       {
59064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59065       };
59066     } catch (std::exception& e) {
59067       {
59068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59069       };
59070     } catch (...) {
59071       {
59072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59073       };
59074     }
59075   }
59076
59077   //argout typemap for const std::string&
59078
59079 }
59080
59081
59082 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59083   char * jresult ;
59084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59085   std::string *result = 0 ;
59086
59087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59088   {
59089     try {
59090       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59091     } catch (std::out_of_range& e) {
59092       {
59093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59094       };
59095     } catch (std::exception& e) {
59096       {
59097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59098       };
59099     } catch (...) {
59100       {
59101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59102       };
59103     }
59104   }
59105   jresult = SWIG_csharp_string_callback(result->c_str());
59106   return jresult;
59107 }
59108
59109
59110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59112   Dali::Vector4 *arg2 = 0 ;
59113
59114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59115   arg2 = (Dali::Vector4 *)jarg2;
59116   if (!arg2) {
59117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59118     return ;
59119   }
59120   {
59121     try {
59122       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59123     } catch (std::out_of_range& e) {
59124       {
59125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59126       };
59127     } catch (std::exception& e) {
59128       {
59129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59130       };
59131     } catch (...) {
59132       {
59133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59134       };
59135     }
59136   }
59137 }
59138
59139
59140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59141   void * jresult ;
59142   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59143   Dali::Vector4 result;
59144
59145   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59146   {
59147     try {
59148       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
59149     } catch (std::out_of_range& e) {
59150       {
59151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59152       };
59153     } catch (std::exception& e) {
59154       {
59155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59156       };
59157     } catch (...) {
59158       {
59159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59160       };
59161     }
59162   }
59163   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59164   return jresult;
59165 }
59166
59167
59168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
59169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59170   Dali::Image arg2 ;
59171   Dali::Image *argp2 ;
59172
59173   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59174   argp2 = (Dali::Image *)jarg2;
59175   if (!argp2) {
59176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
59177     return ;
59178   }
59179   arg2 = *argp2;
59180   {
59181     try {
59182       (arg1)->SetBackgroundImage(arg2);
59183     } catch (std::out_of_range& e) {
59184       {
59185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59186       };
59187     } catch (std::exception& e) {
59188       {
59189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59190       };
59191     } catch (...) {
59192       {
59193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59194       };
59195     }
59196   }
59197 }
59198
59199
59200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59201   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59202   Dali::Property::Map *arg2 = 0 ;
59203
59204   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59205   arg2 = (Dali::Property::Map *)jarg2;
59206   if (!arg2) {
59207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59208     return ;
59209   }
59210   {
59211     try {
59212       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59213     } catch (std::out_of_range& e) {
59214       {
59215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59216       };
59217     } catch (std::exception& e) {
59218       {
59219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59220       };
59221     } catch (...) {
59222       {
59223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59224       };
59225     }
59226   }
59227 }
59228
59229
59230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59231   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59232
59233   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59234   {
59235     try {
59236       (arg1)->ClearBackground();
59237     } catch (std::out_of_range& e) {
59238       {
59239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59240       };
59241     } catch (std::exception& e) {
59242       {
59243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59244       };
59245     } catch (...) {
59246       {
59247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59248       };
59249     }
59250   }
59251 }
59252
59253
59254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59255   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59256   Dali::Gesture::Type arg2 ;
59257
59258   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59259   arg2 = (Dali::Gesture::Type)jarg2;
59260   {
59261     try {
59262       (arg1)->EnableGestureDetection(arg2);
59263     } catch (std::out_of_range& e) {
59264       {
59265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59266       };
59267     } catch (std::exception& e) {
59268       {
59269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59270       };
59271     } catch (...) {
59272       {
59273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59274       };
59275     }
59276   }
59277 }
59278
59279
59280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59281   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59282   Dali::Gesture::Type arg2 ;
59283
59284   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59285   arg2 = (Dali::Gesture::Type)jarg2;
59286   {
59287     try {
59288       (arg1)->DisableGestureDetection(arg2);
59289     } catch (std::out_of_range& e) {
59290       {
59291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59292       };
59293     } catch (std::exception& e) {
59294       {
59295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59296       };
59297     } catch (...) {
59298       {
59299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59300       };
59301     }
59302   }
59303 }
59304
59305
59306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59307   void * jresult ;
59308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59309   Dali::PinchGestureDetector result;
59310
59311   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59312   {
59313     try {
59314       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59315     } catch (std::out_of_range& e) {
59316       {
59317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59318       };
59319     } catch (std::exception& e) {
59320       {
59321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59322       };
59323     } catch (...) {
59324       {
59325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59326       };
59327     }
59328   }
59329   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59330   return jresult;
59331 }
59332
59333
59334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59335   void * jresult ;
59336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59337   Dali::PanGestureDetector result;
59338
59339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59340   {
59341     try {
59342       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59343     } catch (std::out_of_range& e) {
59344       {
59345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59346       };
59347     } catch (std::exception& e) {
59348       {
59349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59350       };
59351     } catch (...) {
59352       {
59353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59354       };
59355     }
59356   }
59357   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59358   return jresult;
59359 }
59360
59361
59362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59363   void * jresult ;
59364   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59365   Dali::TapGestureDetector result;
59366
59367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59368   {
59369     try {
59370       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59371     } catch (std::out_of_range& e) {
59372       {
59373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59374       };
59375     } catch (std::exception& e) {
59376       {
59377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59378       };
59379     } catch (...) {
59380       {
59381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59382       };
59383     }
59384   }
59385   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59386   return jresult;
59387 }
59388
59389
59390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59391   void * jresult ;
59392   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59393   Dali::LongPressGestureDetector result;
59394
59395   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59396   {
59397     try {
59398       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59399     } catch (std::out_of_range& e) {
59400       {
59401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59402       };
59403     } catch (std::exception& e) {
59404       {
59405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59406       };
59407     } catch (...) {
59408       {
59409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59410       };
59411     }
59412   }
59413   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59414   return jresult;
59415 }
59416
59417
59418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59419   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59420   bool arg2 ;
59421
59422   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59423   arg2 = jarg2 ? true : false;
59424   {
59425     try {
59426       (arg1)->SetKeyboardNavigationSupport(arg2);
59427     } catch (std::out_of_range& e) {
59428       {
59429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59430       };
59431     } catch (std::exception& e) {
59432       {
59433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59434       };
59435     } catch (...) {
59436       {
59437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59438       };
59439     }
59440   }
59441 }
59442
59443
59444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59445   unsigned int jresult ;
59446   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59447   bool result;
59448
59449   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59450   {
59451     try {
59452       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59453     } catch (std::out_of_range& e) {
59454       {
59455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59456       };
59457     } catch (std::exception& e) {
59458       {
59459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59460       };
59461     } catch (...) {
59462       {
59463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59464       };
59465     }
59466   }
59467   jresult = result;
59468   return jresult;
59469 }
59470
59471
59472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59474
59475   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59476   {
59477     try {
59478       (arg1)->SetKeyInputFocus();
59479     } catch (std::out_of_range& e) {
59480       {
59481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59482       };
59483     } catch (std::exception& e) {
59484       {
59485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59486       };
59487     } catch (...) {
59488       {
59489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59490       };
59491     }
59492   }
59493 }
59494
59495
59496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59497   unsigned int jresult ;
59498   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59499   bool result;
59500
59501   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59502   {
59503     try {
59504       result = (bool)(arg1)->HasKeyInputFocus();
59505     } catch (std::out_of_range& e) {
59506       {
59507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59508       };
59509     } catch (std::exception& e) {
59510       {
59511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59512       };
59513     } catch (...) {
59514       {
59515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59516       };
59517     }
59518   }
59519   jresult = result;
59520   return jresult;
59521 }
59522
59523
59524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59525   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59526
59527   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59528   {
59529     try {
59530       (arg1)->ClearKeyInputFocus();
59531     } catch (std::out_of_range& e) {
59532       {
59533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59534       };
59535     } catch (std::exception& e) {
59536       {
59537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59538       };
59539     } catch (...) {
59540       {
59541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59542       };
59543     }
59544   }
59545 }
59546
59547
59548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59549   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59550   bool arg2 ;
59551
59552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59553   arg2 = jarg2 ? true : false;
59554   {
59555     try {
59556       (arg1)->SetAsKeyboardFocusGroup(arg2);
59557     } catch (std::out_of_range& e) {
59558       {
59559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59560       };
59561     } catch (std::exception& e) {
59562       {
59563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59564       };
59565     } catch (...) {
59566       {
59567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59568       };
59569     }
59570   }
59571 }
59572
59573
59574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59575   unsigned int jresult ;
59576   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59577   bool result;
59578
59579   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59580   {
59581     try {
59582       result = (bool)(arg1)->IsKeyboardFocusGroup();
59583     } catch (std::out_of_range& e) {
59584       {
59585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59586       };
59587     } catch (std::exception& e) {
59588       {
59589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59590       };
59591     } catch (...) {
59592       {
59593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59594       };
59595     }
59596   }
59597   jresult = result;
59598   return jresult;
59599 }
59600
59601
59602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
59603   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59604
59605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59606   {
59607     try {
59608       (arg1)->AccessibilityActivate();
59609     } catch (std::out_of_range& e) {
59610       {
59611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59612       };
59613     } catch (std::exception& e) {
59614       {
59615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59616       };
59617     } catch (...) {
59618       {
59619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59620       };
59621     }
59622   }
59623 }
59624
59625
59626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
59627   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59628
59629   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59630   {
59631     try {
59632       (arg1)->KeyboardEnter();
59633     } catch (std::out_of_range& e) {
59634       {
59635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59636       };
59637     } catch (std::exception& e) {
59638       {
59639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59640       };
59641     } catch (...) {
59642       {
59643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59644       };
59645     }
59646   }
59647 }
59648
59649
59650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59651   void * jresult ;
59652   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59653   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59654
59655   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59656   {
59657     try {
59658       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59659     } catch (std::out_of_range& e) {
59660       {
59661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59662       };
59663     } catch (std::exception& e) {
59664       {
59665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59666       };
59667     } catch (...) {
59668       {
59669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59670       };
59671     }
59672   }
59673   jresult = (void *)result;
59674   return jresult;
59675 }
59676
59677
59678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59679   void * jresult ;
59680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59681   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59682
59683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59684   {
59685     try {
59686       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59687     } catch (std::out_of_range& e) {
59688       {
59689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59690       };
59691     } catch (std::exception& e) {
59692       {
59693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59694       };
59695     } catch (...) {
59696       {
59697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59698       };
59699     }
59700   }
59701   jresult = (void *)result;
59702   return jresult;
59703 }
59704
59705
59706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59707   void * jresult ;
59708   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59709   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59710
59711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59712   {
59713     try {
59714       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59715     } catch (std::out_of_range& e) {
59716       {
59717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59718       };
59719     } catch (std::exception& e) {
59720       {
59721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59722       };
59723     } catch (...) {
59724       {
59725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59726       };
59727     }
59728   }
59729   jresult = (void *)result;
59730   return jresult;
59731 }
59732
59733
59734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
59735   unsigned int jresult ;
59736   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59737   Dali::KeyEvent *arg2 = 0 ;
59738   bool result;
59739
59740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59741   arg2 = (Dali::KeyEvent *)jarg2;
59742   if (!arg2) {
59743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
59744     return 0;
59745   }
59746   {
59747     try {
59748       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
59749     } catch (std::out_of_range& e) {
59750       {
59751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59752       };
59753     } catch (std::exception& e) {
59754       {
59755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59756       };
59757     } catch (...) {
59758       {
59759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59760       };
59761     }
59762   }
59763   jresult = result;
59764   return jresult;
59765 }
59766
59767
59768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
59769   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59770   int arg2 ;
59771   SwigDirector_ViewImpl *darg = 0;
59772
59773   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59774   arg2 = (int)jarg2;
59775   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59776   {
59777     try {
59778       (darg)->OnStageConnection(arg2);
59779     } catch (std::out_of_range& e) {
59780       {
59781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59782       };
59783     } catch (std::exception& e) {
59784       {
59785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59786       };
59787     } catch (...) {
59788       {
59789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59790       };
59791     }
59792   }
59793 }
59794
59795
59796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59797   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59798   int arg2 ;
59799   SwigDirector_ViewImpl *darg = 0;
59800
59801   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59802   arg2 = (int)jarg2;
59803   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59804   {
59805     try {
59806       (darg)->OnStageConnectionSwigPublic(arg2);
59807     } catch (std::out_of_range& e) {
59808       {
59809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59810       };
59811     } catch (std::exception& e) {
59812       {
59813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59814       };
59815     } catch (...) {
59816       {
59817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59818       };
59819     }
59820   }
59821 }
59822
59823
59824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
59825   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59826   SwigDirector_ViewImpl *darg = 0;
59827
59828   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59829   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59830   {
59831     try {
59832       (darg)->OnStageDisconnection();
59833     } catch (std::out_of_range& e) {
59834       {
59835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59836       };
59837     } catch (std::exception& e) {
59838       {
59839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59840       };
59841     } catch (...) {
59842       {
59843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59844       };
59845     }
59846   }
59847 }
59848
59849
59850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
59851   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59852   SwigDirector_ViewImpl *darg = 0;
59853
59854   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59855   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59856   {
59857     try {
59858       (darg)->OnStageDisconnectionSwigPublic();
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 void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59878   Dali::Actor *arg2 = 0 ;
59879   SwigDirector_ViewImpl *darg = 0;
59880
59881   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59882   arg2 = (Dali::Actor *)jarg2;
59883   if (!arg2) {
59884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59885     return ;
59886   }
59887   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59888   {
59889     try {
59890       (darg)->OnChildAdd(*arg2);
59891     } catch (std::out_of_range& e) {
59892       {
59893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59894       };
59895     } catch (std::exception& e) {
59896       {
59897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59898       };
59899     } catch (...) {
59900       {
59901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59902       };
59903     }
59904   }
59905 }
59906
59907
59908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59910   Dali::Actor *arg2 = 0 ;
59911   SwigDirector_ViewImpl *darg = 0;
59912
59913   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59914   arg2 = (Dali::Actor *)jarg2;
59915   if (!arg2) {
59916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59917     return ;
59918   }
59919   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59920   {
59921     try {
59922       (darg)->OnChildAddSwigPublic(*arg2);
59923     } catch (std::out_of_range& e) {
59924       {
59925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59926       };
59927     } catch (std::exception& e) {
59928       {
59929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59930       };
59931     } catch (...) {
59932       {
59933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59934       };
59935     }
59936   }
59937 }
59938
59939
59940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
59941   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59942   Dali::Actor *arg2 = 0 ;
59943   SwigDirector_ViewImpl *darg = 0;
59944
59945   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59946   arg2 = (Dali::Actor *)jarg2;
59947   if (!arg2) {
59948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59949     return ;
59950   }
59951   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59952   {
59953     try {
59954       (darg)->OnChildRemove(*arg2);
59955     } catch (std::out_of_range& e) {
59956       {
59957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59958       };
59959     } catch (std::exception& e) {
59960       {
59961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59962       };
59963     } catch (...) {
59964       {
59965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59966       };
59967     }
59968   }
59969 }
59970
59971
59972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59973   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59974   Dali::Actor *arg2 = 0 ;
59975   SwigDirector_ViewImpl *darg = 0;
59976
59977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59978   arg2 = (Dali::Actor *)jarg2;
59979   if (!arg2) {
59980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59981     return ;
59982   }
59983   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59984   {
59985     try {
59986       (darg)->OnChildRemoveSwigPublic(*arg2);
59987     } catch (std::out_of_range& e) {
59988       {
59989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59990       };
59991     } catch (std::exception& e) {
59992       {
59993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59994       };
59995     } catch (...) {
59996       {
59997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59998       };
59999     }
60000   }
60001 }
60002
60003
60004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60005   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60006   Dali::Property::Index arg2 ;
60007   Dali::Property::Value arg3 ;
60008   Dali::Property::Value *argp3 ;
60009   SwigDirector_ViewImpl *darg = 0;
60010
60011   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60012   arg2 = (Dali::Property::Index)jarg2;
60013   argp3 = (Dali::Property::Value *)jarg3;
60014   if (!argp3) {
60015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60016     return ;
60017   }
60018   arg3 = *argp3;
60019   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60020   {
60021     try {
60022       (darg)->OnPropertySet(arg2,arg3);
60023     } catch (std::out_of_range& e) {
60024       {
60025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60026       };
60027     } catch (std::exception& e) {
60028       {
60029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60030       };
60031     } catch (...) {
60032       {
60033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60034       };
60035     }
60036   }
60037 }
60038
60039
60040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60041   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60042   Dali::Property::Index arg2 ;
60043   Dali::Property::Value arg3 ;
60044   Dali::Property::Value *argp3 ;
60045   SwigDirector_ViewImpl *darg = 0;
60046
60047   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60048   arg2 = (Dali::Property::Index)jarg2;
60049   argp3 = (Dali::Property::Value *)jarg3;
60050   if (!argp3) {
60051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60052     return ;
60053   }
60054   arg3 = *argp3;
60055   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60056   {
60057     try {
60058       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60059     } catch (std::out_of_range& e) {
60060       {
60061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60062       };
60063     } catch (std::exception& e) {
60064       {
60065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60066       };
60067     } catch (...) {
60068       {
60069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60070       };
60071     }
60072   }
60073 }
60074
60075
60076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60078   Dali::Vector3 *arg2 = 0 ;
60079   SwigDirector_ViewImpl *darg = 0;
60080
60081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60082   arg2 = (Dali::Vector3 *)jarg2;
60083   if (!arg2) {
60084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60085     return ;
60086   }
60087   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60088   {
60089     try {
60090       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60091     } catch (std::out_of_range& e) {
60092       {
60093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60094       };
60095     } catch (std::exception& e) {
60096       {
60097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60098       };
60099     } catch (...) {
60100       {
60101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60102       };
60103     }
60104   }
60105 }
60106
60107
60108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60109   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60110   Dali::Vector3 *arg2 = 0 ;
60111   SwigDirector_ViewImpl *darg = 0;
60112
60113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60114   arg2 = (Dali::Vector3 *)jarg2;
60115   if (!arg2) {
60116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60117     return ;
60118   }
60119   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60120   {
60121     try {
60122       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60123     } catch (std::out_of_range& e) {
60124       {
60125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60126       };
60127     } catch (std::exception& e) {
60128       {
60129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60130       };
60131     } catch (...) {
60132       {
60133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60134       };
60135     }
60136   }
60137 }
60138
60139
60140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60141   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60142   Dali::Animation *arg2 = 0 ;
60143   Dali::Vector3 *arg3 = 0 ;
60144   SwigDirector_ViewImpl *darg = 0;
60145
60146   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60147   arg2 = (Dali::Animation *)jarg2;
60148   if (!arg2) {
60149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60150     return ;
60151   }
60152   arg3 = (Dali::Vector3 *)jarg3;
60153   if (!arg3) {
60154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60155     return ;
60156   }
60157   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60158   {
60159     try {
60160       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60161     } catch (std::out_of_range& e) {
60162       {
60163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60164       };
60165     } catch (std::exception& e) {
60166       {
60167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60168       };
60169     } catch (...) {
60170       {
60171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60172       };
60173     }
60174   }
60175 }
60176
60177
60178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60179   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60180   Dali::Animation *arg2 = 0 ;
60181   Dali::Vector3 *arg3 = 0 ;
60182   SwigDirector_ViewImpl *darg = 0;
60183
60184   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60185   arg2 = (Dali::Animation *)jarg2;
60186   if (!arg2) {
60187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60188     return ;
60189   }
60190   arg3 = (Dali::Vector3 *)jarg3;
60191   if (!arg3) {
60192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60193     return ;
60194   }
60195   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60196   {
60197     try {
60198       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60199     } catch (std::out_of_range& e) {
60200       {
60201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60202       };
60203     } catch (std::exception& e) {
60204       {
60205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60206       };
60207     } catch (...) {
60208       {
60209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60210       };
60211     }
60212   }
60213 }
60214
60215
60216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60217   unsigned int jresult ;
60218   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60219   Dali::TouchEvent *arg2 = 0 ;
60220   SwigDirector_ViewImpl *darg = 0;
60221   bool result;
60222
60223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60224   arg2 = (Dali::TouchEvent *)jarg2;
60225   if (!arg2) {
60226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60227     return 0;
60228   }
60229   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60230   {
60231     try {
60232       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60233     } catch (std::out_of_range& e) {
60234       {
60235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60236       };
60237     } catch (std::exception& e) {
60238       {
60239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60240       };
60241     } catch (...) {
60242       {
60243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60244       };
60245     }
60246   }
60247   jresult = result;
60248   return jresult;
60249 }
60250
60251
60252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60253   unsigned int jresult ;
60254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60255   Dali::TouchEvent *arg2 = 0 ;
60256   SwigDirector_ViewImpl *darg = 0;
60257   bool result;
60258
60259   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60260   arg2 = (Dali::TouchEvent *)jarg2;
60261   if (!arg2) {
60262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60263     return 0;
60264   }
60265   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60266   {
60267     try {
60268       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60269     } catch (std::out_of_range& e) {
60270       {
60271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60272       };
60273     } catch (std::exception& e) {
60274       {
60275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60276       };
60277     } catch (...) {
60278       {
60279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60280       };
60281     }
60282   }
60283   jresult = result;
60284   return jresult;
60285 }
60286
60287
60288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60289   unsigned int jresult ;
60290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60291   Dali::HoverEvent *arg2 = 0 ;
60292   SwigDirector_ViewImpl *darg = 0;
60293   bool result;
60294
60295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60296   arg2 = (Dali::HoverEvent *)jarg2;
60297   if (!arg2) {
60298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60299     return 0;
60300   }
60301   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60302   {
60303     try {
60304       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60305     } catch (std::out_of_range& e) {
60306       {
60307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60308       };
60309     } catch (std::exception& e) {
60310       {
60311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60312       };
60313     } catch (...) {
60314       {
60315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60316       };
60317     }
60318   }
60319   jresult = result;
60320   return jresult;
60321 }
60322
60323
60324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60325   unsigned int jresult ;
60326   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60327   Dali::HoverEvent *arg2 = 0 ;
60328   SwigDirector_ViewImpl *darg = 0;
60329   bool result;
60330
60331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60332   arg2 = (Dali::HoverEvent *)jarg2;
60333   if (!arg2) {
60334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60335     return 0;
60336   }
60337   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60338   {
60339     try {
60340       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
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 = result;
60356   return jresult;
60357 }
60358
60359
60360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60361   unsigned int jresult ;
60362   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60363   Dali::KeyEvent *arg2 = 0 ;
60364   SwigDirector_ViewImpl *darg = 0;
60365   bool result;
60366
60367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60368   arg2 = (Dali::KeyEvent *)jarg2;
60369   if (!arg2) {
60370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60371     return 0;
60372   }
60373   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60374   {
60375     try {
60376       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60377     } catch (std::out_of_range& e) {
60378       {
60379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60380       };
60381     } catch (std::exception& e) {
60382       {
60383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60384       };
60385     } catch (...) {
60386       {
60387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60388       };
60389     }
60390   }
60391   jresult = result;
60392   return jresult;
60393 }
60394
60395
60396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60397   unsigned int jresult ;
60398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60399   Dali::KeyEvent *arg2 = 0 ;
60400   SwigDirector_ViewImpl *darg = 0;
60401   bool result;
60402
60403   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60404   arg2 = (Dali::KeyEvent *)jarg2;
60405   if (!arg2) {
60406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60407     return 0;
60408   }
60409   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60410   {
60411     try {
60412       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60413     } catch (std::out_of_range& e) {
60414       {
60415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60416       };
60417     } catch (std::exception& e) {
60418       {
60419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60420       };
60421     } catch (...) {
60422       {
60423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60424       };
60425     }
60426   }
60427   jresult = result;
60428   return jresult;
60429 }
60430
60431
60432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60433   unsigned int jresult ;
60434   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60435   Dali::WheelEvent *arg2 = 0 ;
60436   SwigDirector_ViewImpl *darg = 0;
60437   bool result;
60438
60439   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60440   arg2 = (Dali::WheelEvent *)jarg2;
60441   if (!arg2) {
60442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60443     return 0;
60444   }
60445   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60446   {
60447     try {
60448       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*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 unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60469   unsigned int jresult ;
60470   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60471   Dali::WheelEvent *arg2 = 0 ;
60472   SwigDirector_ViewImpl *darg = 0;
60473   bool result;
60474
60475   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60476   arg2 = (Dali::WheelEvent *)jarg2;
60477   if (!arg2) {
60478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60479     return 0;
60480   }
60481   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60482   {
60483     try {
60484       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60485     } catch (std::out_of_range& e) {
60486       {
60487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60488       };
60489     } catch (std::exception& e) {
60490       {
60491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60492       };
60493     } catch (...) {
60494       {
60495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60496       };
60497     }
60498   }
60499   jresult = result;
60500   return jresult;
60501 }
60502
60503
60504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60505   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60506   Dali::Vector2 *arg2 = 0 ;
60507   Dali::RelayoutContainer *arg3 = 0 ;
60508   SwigDirector_ViewImpl *darg = 0;
60509
60510   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60511   arg2 = (Dali::Vector2 *)jarg2;
60512   if (!arg2) {
60513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60514     return ;
60515   }
60516   arg3 = (Dali::RelayoutContainer *)jarg3;
60517   if (!arg3) {
60518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60519     return ;
60520   }
60521   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60522   {
60523     try {
60524       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60525     } catch (std::out_of_range& e) {
60526       {
60527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60528       };
60529     } catch (std::exception& e) {
60530       {
60531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60532       };
60533     } catch (...) {
60534       {
60535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60536       };
60537     }
60538   }
60539 }
60540
60541
60542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60543   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60544   Dali::Vector2 *arg2 = 0 ;
60545   Dali::RelayoutContainer *arg3 = 0 ;
60546   SwigDirector_ViewImpl *darg = 0;
60547
60548   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60549   arg2 = (Dali::Vector2 *)jarg2;
60550   if (!arg2) {
60551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60552     return ;
60553   }
60554   arg3 = (Dali::RelayoutContainer *)jarg3;
60555   if (!arg3) {
60556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60557     return ;
60558   }
60559   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60560   {
60561     try {
60562       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60563     } catch (std::out_of_range& e) {
60564       {
60565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60566       };
60567     } catch (std::exception& e) {
60568       {
60569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60570       };
60571     } catch (...) {
60572       {
60573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60574       };
60575     }
60576   }
60577 }
60578
60579
60580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60581   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60582   Dali::ResizePolicy::Type arg2 ;
60583   Dali::Dimension::Type arg3 ;
60584   SwigDirector_ViewImpl *darg = 0;
60585
60586   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60587   arg2 = (Dali::ResizePolicy::Type)jarg2;
60588   arg3 = (Dali::Dimension::Type)jarg3;
60589   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60590   {
60591     try {
60592       (darg)->OnSetResizePolicy(arg2,arg3);
60593     } catch (std::out_of_range& e) {
60594       {
60595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60596       };
60597     } catch (std::exception& e) {
60598       {
60599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60600       };
60601     } catch (...) {
60602       {
60603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60604       };
60605     }
60606   }
60607 }
60608
60609
60610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60611   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60612   Dali::ResizePolicy::Type arg2 ;
60613   Dali::Dimension::Type arg3 ;
60614   SwigDirector_ViewImpl *darg = 0;
60615
60616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60617   arg2 = (Dali::ResizePolicy::Type)jarg2;
60618   arg3 = (Dali::Dimension::Type)jarg3;
60619   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60620   {
60621     try {
60622       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60623     } catch (std::out_of_range& e) {
60624       {
60625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60626       };
60627     } catch (std::exception& e) {
60628       {
60629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60630       };
60631     } catch (...) {
60632       {
60633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60634       };
60635     }
60636   }
60637 }
60638
60639
60640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60641   void * jresult ;
60642   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60643   SwigDirector_ViewImpl *darg = 0;
60644   Dali::Vector3 result;
60645
60646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60647   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60648   {
60649     try {
60650       result = (darg)->GetNaturalSize();
60651     } catch (std::out_of_range& e) {
60652       {
60653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60654       };
60655     } catch (std::exception& e) {
60656       {
60657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60658       };
60659     } catch (...) {
60660       {
60661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60662       };
60663     }
60664   }
60665   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60666   return jresult;
60667 }
60668
60669
60670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60671   void * jresult ;
60672   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60673   SwigDirector_ViewImpl *darg = 0;
60674   Dali::Vector3 result;
60675
60676   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60677   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60678   {
60679     try {
60680       result = (darg)->GetNaturalSizeSwigPublic();
60681     } catch (std::out_of_range& e) {
60682       {
60683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60684       };
60685     } catch (std::exception& e) {
60686       {
60687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60688       };
60689     } catch (...) {
60690       {
60691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60692       };
60693     }
60694   }
60695   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60696   return jresult;
60697 }
60698
60699
60700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60701   float jresult ;
60702   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60703   Dali::Actor *arg2 = 0 ;
60704   Dali::Dimension::Type arg3 ;
60705   SwigDirector_ViewImpl *darg = 0;
60706   float result;
60707
60708   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60709   arg2 = (Dali::Actor *)jarg2;
60710   if (!arg2) {
60711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60712     return 0;
60713   }
60714   arg3 = (Dali::Dimension::Type)jarg3;
60715   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60716   {
60717     try {
60718       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60719     } catch (std::out_of_range& e) {
60720       {
60721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60722       };
60723     } catch (std::exception& e) {
60724       {
60725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60726       };
60727     } catch (...) {
60728       {
60729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60730       };
60731     }
60732   }
60733   jresult = result;
60734   return jresult;
60735 }
60736
60737
60738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60739   float jresult ;
60740   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60741   Dali::Actor *arg2 = 0 ;
60742   Dali::Dimension::Type arg3 ;
60743   SwigDirector_ViewImpl *darg = 0;
60744   float result;
60745
60746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60747   arg2 = (Dali::Actor *)jarg2;
60748   if (!arg2) {
60749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60750     return 0;
60751   }
60752   arg3 = (Dali::Dimension::Type)jarg3;
60753   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60754   {
60755     try {
60756       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60757     } catch (std::out_of_range& e) {
60758       {
60759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60760       };
60761     } catch (std::exception& e) {
60762       {
60763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60764       };
60765     } catch (...) {
60766       {
60767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60768       };
60769     }
60770   }
60771   jresult = result;
60772   return jresult;
60773 }
60774
60775
60776 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60777   float jresult ;
60778   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60779   float arg2 ;
60780   SwigDirector_ViewImpl *darg = 0;
60781   float result;
60782
60783   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60784   arg2 = (float)jarg2;
60785   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60786   {
60787     try {
60788       result = (float)(darg)->GetHeightForWidth(arg2);
60789     } catch (std::out_of_range& e) {
60790       {
60791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60792       };
60793     } catch (std::exception& e) {
60794       {
60795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60796       };
60797     } catch (...) {
60798       {
60799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60800       };
60801     }
60802   }
60803   jresult = result;
60804   return jresult;
60805 }
60806
60807
60808 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
60809   float jresult ;
60810   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60811   float arg2 ;
60812   SwigDirector_ViewImpl *darg = 0;
60813   float result;
60814
60815   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60816   arg2 = (float)jarg2;
60817   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60818   {
60819     try {
60820       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
60821     } catch (std::out_of_range& e) {
60822       {
60823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60824       };
60825     } catch (std::exception& e) {
60826       {
60827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60828       };
60829     } catch (...) {
60830       {
60831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60832       };
60833     }
60834   }
60835   jresult = result;
60836   return jresult;
60837 }
60838
60839
60840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
60841   float jresult ;
60842   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60843   float arg2 ;
60844   SwigDirector_ViewImpl *darg = 0;
60845   float result;
60846
60847   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60848   arg2 = (float)jarg2;
60849   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60850   {
60851     try {
60852       result = (float)(darg)->GetWidthForHeight(arg2);
60853     } catch (std::out_of_range& e) {
60854       {
60855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60856       };
60857     } catch (std::exception& e) {
60858       {
60859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60860       };
60861     } catch (...) {
60862       {
60863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60864       };
60865     }
60866   }
60867   jresult = result;
60868   return jresult;
60869 }
60870
60871
60872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
60873   float jresult ;
60874   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60875   float arg2 ;
60876   SwigDirector_ViewImpl *darg = 0;
60877   float result;
60878
60879   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60880   arg2 = (float)jarg2;
60881   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60882   {
60883     try {
60884       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
60885     } catch (std::out_of_range& e) {
60886       {
60887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60888       };
60889     } catch (std::exception& e) {
60890       {
60891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60892       };
60893     } catch (...) {
60894       {
60895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60896       };
60897     }
60898   }
60899   jresult = result;
60900   return jresult;
60901 }
60902
60903
60904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
60905   unsigned int jresult ;
60906   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60907   Dali::Dimension::Type arg2 ;
60908   SwigDirector_ViewImpl *darg = 0;
60909   bool result;
60910
60911   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60912   arg2 = (Dali::Dimension::Type)jarg2;
60913   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60914   {
60915     try {
60916       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
60917     } catch (std::out_of_range& e) {
60918       {
60919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60920       };
60921     } catch (std::exception& e) {
60922       {
60923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60924       };
60925     } catch (...) {
60926       {
60927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60928       };
60929     }
60930   }
60931   jresult = result;
60932   return jresult;
60933 }
60934
60935
60936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
60937   unsigned int jresult ;
60938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60939   Dali::Dimension::Type arg2 ;
60940   SwigDirector_ViewImpl *darg = 0;
60941   bool result;
60942
60943   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60944   arg2 = (Dali::Dimension::Type)jarg2;
60945   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60946   {
60947     try {
60948       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
60949     } catch (std::out_of_range& e) {
60950       {
60951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60952       };
60953     } catch (std::exception& e) {
60954       {
60955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60956       };
60957     } catch (...) {
60958       {
60959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60960       };
60961     }
60962   }
60963   jresult = result;
60964   return jresult;
60965 }
60966
60967
60968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
60969   unsigned int jresult ;
60970   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60971   SwigDirector_ViewImpl *darg = 0;
60972   bool result;
60973
60974   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60975   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60976   {
60977     try {
60978       result = (bool)(darg)->RelayoutDependentOnChildren();
60979     } catch (std::out_of_range& e) {
60980       {
60981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60982       };
60983     } catch (std::exception& e) {
60984       {
60985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60986       };
60987     } catch (...) {
60988       {
60989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60990       };
60991     }
60992   }
60993   jresult = result;
60994   return jresult;
60995 }
60996
60997
60998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
60999   unsigned int jresult ;
61000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61001   SwigDirector_ViewImpl *darg = 0;
61002   bool result;
61003
61004   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61005   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61006   {
61007     try {
61008       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61009     } catch (std::out_of_range& e) {
61010       {
61011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61012       };
61013     } catch (std::exception& e) {
61014       {
61015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61016       };
61017     } catch (...) {
61018       {
61019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61020       };
61021     }
61022   }
61023   jresult = result;
61024   return jresult;
61025 }
61026
61027
61028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61030   Dali::Dimension::Type arg2 ;
61031   SwigDirector_ViewImpl *darg = 0;
61032
61033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61034   arg2 = (Dali::Dimension::Type)jarg2;
61035   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61036   {
61037     try {
61038       (darg)->OnCalculateRelayoutSize(arg2);
61039     } catch (std::out_of_range& e) {
61040       {
61041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61042       };
61043     } catch (std::exception& e) {
61044       {
61045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61046       };
61047     } catch (...) {
61048       {
61049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61050       };
61051     }
61052   }
61053 }
61054
61055
61056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61057   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61058   Dali::Dimension::Type arg2 ;
61059   SwigDirector_ViewImpl *darg = 0;
61060
61061   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61062   arg2 = (Dali::Dimension::Type)jarg2;
61063   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61064   {
61065     try {
61066       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61067     } catch (std::out_of_range& e) {
61068       {
61069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61070       };
61071     } catch (std::exception& e) {
61072       {
61073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61074       };
61075     } catch (...) {
61076       {
61077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61078       };
61079     }
61080   }
61081 }
61082
61083
61084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61085   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61086   float arg2 ;
61087   Dali::Dimension::Type arg3 ;
61088   SwigDirector_ViewImpl *darg = 0;
61089
61090   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61091   arg2 = (float)jarg2;
61092   arg3 = (Dali::Dimension::Type)jarg3;
61093   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61094   {
61095     try {
61096       (darg)->OnLayoutNegotiated(arg2,arg3);
61097     } catch (std::out_of_range& e) {
61098       {
61099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61100       };
61101     } catch (std::exception& e) {
61102       {
61103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61104       };
61105     } catch (...) {
61106       {
61107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61108       };
61109     }
61110   }
61111 }
61112
61113
61114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61116   float arg2 ;
61117   Dali::Dimension::Type arg3 ;
61118   SwigDirector_ViewImpl *darg = 0;
61119
61120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61121   arg2 = (float)jarg2;
61122   arg3 = (Dali::Dimension::Type)jarg3;
61123   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61124   {
61125     try {
61126       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61127     } catch (std::out_of_range& e) {
61128       {
61129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61130       };
61131     } catch (std::exception& e) {
61132       {
61133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61134       };
61135     } catch (...) {
61136       {
61137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61138       };
61139     }
61140   }
61141 }
61142
61143
61144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61145   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61146
61147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61148   {
61149     try {
61150       (arg1)->OnInitialize();
61151     } catch (std::out_of_range& e) {
61152       {
61153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61154       };
61155     } catch (std::exception& e) {
61156       {
61157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61158       };
61159     } catch (...) {
61160       {
61161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61162       };
61163     }
61164   }
61165 }
61166
61167
61168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61170
61171   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61172   {
61173     try {
61174       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61175     } catch (std::out_of_range& e) {
61176       {
61177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61178       };
61179     } catch (std::exception& e) {
61180       {
61181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61182       };
61183     } catch (...) {
61184       {
61185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61186       };
61187     }
61188   }
61189 }
61190
61191
61192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
61193   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61194   Dali::Actor *arg2 = 0 ;
61195
61196   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61197   arg2 = (Dali::Actor *)jarg2;
61198   if (!arg2) {
61199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61200     return ;
61201   }
61202   {
61203     try {
61204       (arg1)->OnControlChildAdd(*arg2);
61205     } catch (std::out_of_range& e) {
61206       {
61207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61208       };
61209     } catch (std::exception& e) {
61210       {
61211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61212       };
61213     } catch (...) {
61214       {
61215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61216       };
61217     }
61218   }
61219 }
61220
61221
61222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61223   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61224   Dali::Actor *arg2 = 0 ;
61225
61226   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61227   arg2 = (Dali::Actor *)jarg2;
61228   if (!arg2) {
61229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61230     return ;
61231   }
61232   {
61233     try {
61234       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
61235     } catch (std::out_of_range& e) {
61236       {
61237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61238       };
61239     } catch (std::exception& e) {
61240       {
61241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61242       };
61243     } catch (...) {
61244       {
61245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61246       };
61247     }
61248   }
61249 }
61250
61251
61252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
61253   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61254   Dali::Actor *arg2 = 0 ;
61255
61256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61257   arg2 = (Dali::Actor *)jarg2;
61258   if (!arg2) {
61259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61260     return ;
61261   }
61262   {
61263     try {
61264       (arg1)->OnControlChildRemove(*arg2);
61265     } catch (std::out_of_range& e) {
61266       {
61267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61268       };
61269     } catch (std::exception& e) {
61270       {
61271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61272       };
61273     } catch (...) {
61274       {
61275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61276       };
61277     }
61278   }
61279 }
61280
61281
61282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61283   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61284   Dali::Actor *arg2 = 0 ;
61285
61286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61287   arg2 = (Dali::Actor *)jarg2;
61288   if (!arg2) {
61289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
61290     return ;
61291   }
61292   {
61293     try {
61294       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
61295     } catch (std::out_of_range& e) {
61296       {
61297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61298       };
61299     } catch (std::exception& e) {
61300       {
61301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61302       };
61303     } catch (...) {
61304       {
61305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61306       };
61307     }
61308   }
61309 }
61310
61311
61312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61313   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61314   Dali::Toolkit::StyleManager arg2 ;
61315   Dali::StyleChange::Type arg3 ;
61316   Dali::Toolkit::StyleManager *argp2 ;
61317
61318   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61319   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61320   if (!argp2) {
61321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61322     return ;
61323   }
61324   arg2 = *argp2;
61325   arg3 = (Dali::StyleChange::Type)jarg3;
61326   {
61327     try {
61328       (arg1)->OnStyleChange(arg2,arg3);
61329     } catch (std::out_of_range& e) {
61330       {
61331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61332       };
61333     } catch (std::exception& e) {
61334       {
61335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61336       };
61337     } catch (...) {
61338       {
61339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61340       };
61341     }
61342   }
61343 }
61344
61345
61346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61347   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61348   Dali::Toolkit::StyleManager arg2 ;
61349   Dali::StyleChange::Type arg3 ;
61350   Dali::Toolkit::StyleManager *argp2 ;
61351
61352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61353   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61354   if (!argp2) {
61355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61356     return ;
61357   }
61358   arg2 = *argp2;
61359   arg3 = (Dali::StyleChange::Type)jarg3;
61360   {
61361     try {
61362       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61363     } catch (std::out_of_range& e) {
61364       {
61365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61366       };
61367     } catch (std::exception& e) {
61368       {
61369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61370       };
61371     } catch (...) {
61372       {
61373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61374       };
61375     }
61376   }
61377 }
61378
61379
61380 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61381   unsigned int jresult ;
61382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61383   bool result;
61384
61385   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61386   {
61387     try {
61388       result = (bool)(arg1)->OnAccessibilityActivated();
61389     } catch (std::out_of_range& e) {
61390       {
61391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61392       };
61393     } catch (std::exception& e) {
61394       {
61395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61396       };
61397     } catch (...) {
61398       {
61399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61400       };
61401     }
61402   }
61403   jresult = result;
61404   return jresult;
61405 }
61406
61407
61408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61409   unsigned int jresult ;
61410   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61411   bool result;
61412
61413   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61414   {
61415     try {
61416       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61417     } catch (std::out_of_range& e) {
61418       {
61419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61420       };
61421     } catch (std::exception& e) {
61422       {
61423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61424       };
61425     } catch (...) {
61426       {
61427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61428       };
61429     }
61430   }
61431   jresult = result;
61432   return jresult;
61433 }
61434
61435
61436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61437   unsigned int jresult ;
61438   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61439   Dali::PanGesture arg2 ;
61440   Dali::PanGesture *argp2 ;
61441   bool result;
61442
61443   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61444   argp2 = (Dali::PanGesture *)jarg2;
61445   if (!argp2) {
61446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61447     return 0;
61448   }
61449   arg2 = *argp2;
61450   {
61451     try {
61452       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61453     } catch (std::out_of_range& e) {
61454       {
61455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61456       };
61457     } catch (std::exception& e) {
61458       {
61459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61460       };
61461     } catch (...) {
61462       {
61463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61464       };
61465     }
61466   }
61467   jresult = result;
61468   return jresult;
61469 }
61470
61471
61472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61473   unsigned int jresult ;
61474   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61475   Dali::PanGesture arg2 ;
61476   Dali::PanGesture *argp2 ;
61477   bool result;
61478
61479   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61480   argp2 = (Dali::PanGesture *)jarg2;
61481   if (!argp2) {
61482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61483     return 0;
61484   }
61485   arg2 = *argp2;
61486   {
61487     try {
61488       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61489     } catch (std::out_of_range& e) {
61490       {
61491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61492       };
61493     } catch (std::exception& e) {
61494       {
61495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61496       };
61497     } catch (...) {
61498       {
61499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61500       };
61501     }
61502   }
61503   jresult = result;
61504   return jresult;
61505 }
61506
61507
61508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61509   unsigned int jresult ;
61510   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61511   Dali::TouchEvent *arg2 = 0 ;
61512   bool result;
61513
61514   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61515   arg2 = (Dali::TouchEvent *)jarg2;
61516   if (!arg2) {
61517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61518     return 0;
61519   }
61520   {
61521     try {
61522       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61523     } catch (std::out_of_range& e) {
61524       {
61525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61526       };
61527     } catch (std::exception& e) {
61528       {
61529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61530       };
61531     } catch (...) {
61532       {
61533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61534       };
61535     }
61536   }
61537   jresult = result;
61538   return jresult;
61539 }
61540
61541
61542 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61543   unsigned int jresult ;
61544   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61545   Dali::TouchEvent *arg2 = 0 ;
61546   bool result;
61547
61548   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61549   arg2 = (Dali::TouchEvent *)jarg2;
61550   if (!arg2) {
61551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61552     return 0;
61553   }
61554   {
61555     try {
61556       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61557     } catch (std::out_of_range& e) {
61558       {
61559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61560       };
61561     } catch (std::exception& e) {
61562       {
61563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61564       };
61565     } catch (...) {
61566       {
61567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61568       };
61569     }
61570   }
61571   jresult = result;
61572   return jresult;
61573 }
61574
61575
61576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61577   unsigned int jresult ;
61578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61579   bool arg2 ;
61580   bool result;
61581
61582   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61583   arg2 = jarg2 ? true : false;
61584   {
61585     try {
61586       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61587     } catch (std::out_of_range& e) {
61588       {
61589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61590       };
61591     } catch (std::exception& e) {
61592       {
61593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61594       };
61595     } catch (...) {
61596       {
61597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61598       };
61599     }
61600   }
61601   jresult = result;
61602   return jresult;
61603 }
61604
61605
61606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61607   unsigned int jresult ;
61608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61609   bool arg2 ;
61610   bool result;
61611
61612   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61613   arg2 = jarg2 ? true : false;
61614   {
61615     try {
61616       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61617     } catch (std::out_of_range& e) {
61618       {
61619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61620       };
61621     } catch (std::exception& e) {
61622       {
61623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61624       };
61625     } catch (...) {
61626       {
61627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61628       };
61629     }
61630   }
61631   jresult = result;
61632   return jresult;
61633 }
61634
61635
61636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61637   unsigned int jresult ;
61638   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61639   bool result;
61640
61641   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61642   {
61643     try {
61644       result = (bool)(arg1)->OnAccessibilityZoom();
61645     } catch (std::out_of_range& e) {
61646       {
61647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61648       };
61649     } catch (std::exception& e) {
61650       {
61651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61652       };
61653     } catch (...) {
61654       {
61655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61656       };
61657     }
61658   }
61659   jresult = result;
61660   return jresult;
61661 }
61662
61663
61664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61665   unsigned int jresult ;
61666   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61667   bool result;
61668
61669   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61670   {
61671     try {
61672       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61673     } catch (std::out_of_range& e) {
61674       {
61675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61676       };
61677     } catch (std::exception& e) {
61678       {
61679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61680       };
61681     } catch (...) {
61682       {
61683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61684       };
61685     }
61686   }
61687   jresult = result;
61688   return jresult;
61689 }
61690
61691
61692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61693   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61694
61695   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61696   {
61697     try {
61698       (arg1)->OnKeyInputFocusGained();
61699     } catch (std::out_of_range& e) {
61700       {
61701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61702       };
61703     } catch (std::exception& e) {
61704       {
61705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61706       };
61707     } catch (...) {
61708       {
61709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61710       };
61711     }
61712   }
61713 }
61714
61715
61716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61717   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61718
61719   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61720   {
61721     try {
61722       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61723     } catch (std::out_of_range& e) {
61724       {
61725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61726       };
61727     } catch (std::exception& e) {
61728       {
61729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61730       };
61731     } catch (...) {
61732       {
61733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61734       };
61735     }
61736   }
61737 }
61738
61739
61740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61741   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61742
61743   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61744   {
61745     try {
61746       (arg1)->OnKeyInputFocusLost();
61747     } catch (std::out_of_range& e) {
61748       {
61749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61750       };
61751     } catch (std::exception& e) {
61752       {
61753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61754       };
61755     } catch (...) {
61756       {
61757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61758       };
61759     }
61760   }
61761 }
61762
61763
61764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61765   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61766
61767   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61768   {
61769     try {
61770       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61771     } catch (std::out_of_range& e) {
61772       {
61773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61774       };
61775     } catch (std::exception& e) {
61776       {
61777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61778       };
61779     } catch (...) {
61780       {
61781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61782       };
61783     }
61784   }
61785 }
61786
61787
61788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61789   void * jresult ;
61790   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61791   Dali::Actor arg2 ;
61792   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61793   bool arg4 ;
61794   Dali::Actor *argp2 ;
61795   Dali::Actor result;
61796
61797   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61798   argp2 = (Dali::Actor *)jarg2;
61799   if (!argp2) {
61800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61801     return 0;
61802   }
61803   arg2 = *argp2;
61804   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61805   arg4 = jarg4 ? true : false;
61806   {
61807     try {
61808       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61809     } catch (std::out_of_range& e) {
61810       {
61811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61812       };
61813     } catch (std::exception& e) {
61814       {
61815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61816       };
61817     } catch (...) {
61818       {
61819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61820       };
61821     }
61822   }
61823   jresult = new Dali::Actor((const Dali::Actor &)result);
61824   return jresult;
61825 }
61826
61827
61828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61829   void * jresult ;
61830   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61831   Dali::Actor arg2 ;
61832   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61833   bool arg4 ;
61834   Dali::Actor *argp2 ;
61835   Dali::Actor result;
61836
61837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61838   argp2 = (Dali::Actor *)jarg2;
61839   if (!argp2) {
61840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61841     return 0;
61842   }
61843   arg2 = *argp2;
61844   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61845   arg4 = jarg4 ? true : false;
61846   {
61847     try {
61848       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61849     } catch (std::out_of_range& e) {
61850       {
61851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61852       };
61853     } catch (std::exception& e) {
61854       {
61855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61856       };
61857     } catch (...) {
61858       {
61859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61860       };
61861     }
61862   }
61863   jresult = new Dali::Actor((const Dali::Actor &)result);
61864   return jresult;
61865 }
61866
61867
61868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
61869   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61870   Dali::Actor arg2 ;
61871   Dali::Actor *argp2 ;
61872
61873   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61874   argp2 = (Dali::Actor *)jarg2;
61875   if (!argp2) {
61876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61877     return ;
61878   }
61879   arg2 = *argp2;
61880   {
61881     try {
61882       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
61883     } catch (std::out_of_range& e) {
61884       {
61885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61886       };
61887     } catch (std::exception& e) {
61888       {
61889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61890       };
61891     } catch (...) {
61892       {
61893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61894       };
61895     }
61896   }
61897 }
61898
61899
61900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61901   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61902   Dali::Actor arg2 ;
61903   Dali::Actor *argp2 ;
61904
61905   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61906   argp2 = (Dali::Actor *)jarg2;
61907   if (!argp2) {
61908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61909     return ;
61910   }
61911   arg2 = *argp2;
61912   {
61913     try {
61914       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
61915     } catch (std::out_of_range& e) {
61916       {
61917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61918       };
61919     } catch (std::exception& e) {
61920       {
61921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61922       };
61923     } catch (...) {
61924       {
61925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61926       };
61927     }
61928   }
61929 }
61930
61931
61932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
61933   unsigned int jresult ;
61934   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61935   bool result;
61936
61937   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61938   {
61939     try {
61940       result = (bool)(arg1)->OnKeyboardEnter();
61941     } catch (std::out_of_range& e) {
61942       {
61943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61944       };
61945     } catch (std::exception& e) {
61946       {
61947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61948       };
61949     } catch (...) {
61950       {
61951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61952       };
61953     }
61954   }
61955   jresult = result;
61956   return jresult;
61957 }
61958
61959
61960 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
61961   unsigned int jresult ;
61962   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61963   bool result;
61964
61965   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61966   {
61967     try {
61968       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
61969     } catch (std::out_of_range& e) {
61970       {
61971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61972       };
61973     } catch (std::exception& e) {
61974       {
61975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61976       };
61977     } catch (...) {
61978       {
61979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61980       };
61981     }
61982   }
61983   jresult = result;
61984   return jresult;
61985 }
61986
61987
61988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
61989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61990   Dali::PinchGesture *arg2 = 0 ;
61991
61992   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61993   arg2 = (Dali::PinchGesture *)jarg2;
61994   if (!arg2) {
61995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
61996     return ;
61997   }
61998   {
61999     try {
62000       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62001     } catch (std::out_of_range& e) {
62002       {
62003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62004       };
62005     } catch (std::exception& e) {
62006       {
62007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62008       };
62009     } catch (...) {
62010       {
62011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62012       };
62013     }
62014   }
62015 }
62016
62017
62018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62019   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62020   Dali::PinchGesture *arg2 = 0 ;
62021
62022   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62023   arg2 = (Dali::PinchGesture *)jarg2;
62024   if (!arg2) {
62025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62026     return ;
62027   }
62028   {
62029     try {
62030       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62031     } catch (std::out_of_range& e) {
62032       {
62033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62034       };
62035     } catch (std::exception& e) {
62036       {
62037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62038       };
62039     } catch (...) {
62040       {
62041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62042       };
62043     }
62044   }
62045 }
62046
62047
62048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62050   Dali::PanGesture *arg2 = 0 ;
62051
62052   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62053   arg2 = (Dali::PanGesture *)jarg2;
62054   if (!arg2) {
62055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62056     return ;
62057   }
62058   {
62059     try {
62060       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62061     } catch (std::out_of_range& e) {
62062       {
62063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62064       };
62065     } catch (std::exception& e) {
62066       {
62067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62068       };
62069     } catch (...) {
62070       {
62071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62072       };
62073     }
62074   }
62075 }
62076
62077
62078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62079   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62080   Dali::PanGesture *arg2 = 0 ;
62081
62082   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62083   arg2 = (Dali::PanGesture *)jarg2;
62084   if (!arg2) {
62085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62086     return ;
62087   }
62088   {
62089     try {
62090       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62091     } catch (std::out_of_range& e) {
62092       {
62093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62094       };
62095     } catch (std::exception& e) {
62096       {
62097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62098       };
62099     } catch (...) {
62100       {
62101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62102       };
62103     }
62104   }
62105 }
62106
62107
62108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62109   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62110   Dali::TapGesture *arg2 = 0 ;
62111
62112   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62113   arg2 = (Dali::TapGesture *)jarg2;
62114   if (!arg2) {
62115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62116     return ;
62117   }
62118   {
62119     try {
62120       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62121     } catch (std::out_of_range& e) {
62122       {
62123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62124       };
62125     } catch (std::exception& e) {
62126       {
62127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62128       };
62129     } catch (...) {
62130       {
62131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62132       };
62133     }
62134   }
62135 }
62136
62137
62138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62139   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62140   Dali::TapGesture *arg2 = 0 ;
62141
62142   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62143   arg2 = (Dali::TapGesture *)jarg2;
62144   if (!arg2) {
62145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62146     return ;
62147   }
62148   {
62149     try {
62150       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62151     } catch (std::out_of_range& e) {
62152       {
62153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62154       };
62155     } catch (std::exception& e) {
62156       {
62157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62158       };
62159     } catch (...) {
62160       {
62161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62162       };
62163     }
62164   }
62165 }
62166
62167
62168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62170   Dali::LongPressGesture *arg2 = 0 ;
62171
62172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62173   arg2 = (Dali::LongPressGesture *)jarg2;
62174   if (!arg2) {
62175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62176     return ;
62177   }
62178   {
62179     try {
62180       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62181     } catch (std::out_of_range& e) {
62182       {
62183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62184       };
62185     } catch (std::exception& e) {
62186       {
62187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62188       };
62189     } catch (...) {
62190       {
62191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62192       };
62193     }
62194   }
62195 }
62196
62197
62198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62199   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62200   Dali::LongPressGesture *arg2 = 0 ;
62201
62202   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62203   arg2 = (Dali::LongPressGesture *)jarg2;
62204   if (!arg2) {
62205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62206     return ;
62207   }
62208   {
62209     try {
62210       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62211     } catch (std::out_of_range& e) {
62212       {
62213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62214       };
62215     } catch (std::exception& e) {
62216       {
62217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62218       };
62219     } catch (...) {
62220       {
62221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62222       };
62223     }
62224   }
62225 }
62226
62227
62228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62229   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62230   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62231   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62232
62233   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62234   arg2 = (Dali::SlotObserver *)jarg2;
62235   arg3 = (Dali::CallbackBase *)jarg3;
62236   {
62237     try {
62238       (arg1)->SignalConnected(arg2,arg3);
62239     } catch (std::out_of_range& e) {
62240       {
62241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62242       };
62243     } catch (std::exception& e) {
62244       {
62245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62246       };
62247     } catch (...) {
62248       {
62249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62250       };
62251     }
62252   }
62253 }
62254
62255
62256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62258   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62259   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62260
62261   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62262   arg2 = (Dali::SlotObserver *)jarg2;
62263   arg3 = (Dali::CallbackBase *)jarg3;
62264   {
62265     try {
62266       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62267     } catch (std::out_of_range& e) {
62268       {
62269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62270       };
62271     } catch (std::exception& e) {
62272       {
62273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62274       };
62275     } catch (...) {
62276       {
62277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62278       };
62279     }
62280   }
62281 }
62282
62283
62284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62285   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62286   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62287   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62288
62289   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62290   arg2 = (Dali::SlotObserver *)jarg2;
62291   arg3 = (Dali::CallbackBase *)jarg3;
62292   {
62293     try {
62294       (arg1)->SignalDisconnected(arg2,arg3);
62295     } catch (std::out_of_range& e) {
62296       {
62297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62298       };
62299     } catch (std::exception& e) {
62300       {
62301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62302       };
62303     } catch (...) {
62304       {
62305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62306       };
62307     }
62308   }
62309 }
62310
62311
62312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62313   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62314   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62315   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62316
62317   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62318   arg2 = (Dali::SlotObserver *)jarg2;
62319   arg3 = (Dali::CallbackBase *)jarg3;
62320   {
62321     try {
62322       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62323     } catch (std::out_of_range& e) {
62324       {
62325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62326       };
62327     } catch (std::exception& e) {
62328       {
62329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62330       };
62331     } catch (...) {
62332       {
62333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62334       };
62335     }
62336   }
62337 }
62338
62339
62340 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) {
62341   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62342   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62343   if (director) {
62344     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);
62345   }
62346 }
62347
62348
62349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62350   void * jresult ;
62351   Dali::Toolkit::Control *arg1 = 0 ;
62352   Dali::Toolkit::Internal::Control *result = 0 ;
62353
62354   arg1 = (Dali::Toolkit::Control *)jarg1;
62355   if (!arg1) {
62356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62357     return 0;
62358   }
62359   {
62360     try {
62361       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62362     } catch (std::out_of_range& e) {
62363       {
62364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62365       };
62366     } catch (std::exception& e) {
62367       {
62368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62369       };
62370     } catch (...) {
62371       {
62372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62373       };
62374     }
62375   }
62376   jresult = (void *)result;
62377   return jresult;
62378 }
62379
62380
62381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62382   int jresult ;
62383   int result;
62384
62385   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62386   jresult = (int)result;
62387   return jresult;
62388 }
62389
62390
62391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
62392   int jresult ;
62393   int result;
62394
62395   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
62396   jresult = (int)result;
62397   return jresult;
62398 }
62399
62400
62401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
62402   int jresult ;
62403   int result;
62404
62405   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
62406   jresult = (int)result;
62407   return jresult;
62408 }
62409
62410
62411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62412   int jresult ;
62413   int result;
62414
62415   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62416   jresult = (int)result;
62417   return jresult;
62418 }
62419
62420
62421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62422   int jresult ;
62423   int result;
62424
62425   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62426   jresult = (int)result;
62427   return jresult;
62428 }
62429
62430
62431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62432   void * jresult ;
62433   Dali::Toolkit::Control::Property *result = 0 ;
62434
62435   {
62436     try {
62437       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62438     } catch (std::out_of_range& e) {
62439       {
62440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62441       };
62442     } catch (std::exception& e) {
62443       {
62444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62445       };
62446     } catch (...) {
62447       {
62448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62449       };
62450     }
62451   }
62452   jresult = (void *)result;
62453   return jresult;
62454 }
62455
62456
62457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62458   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62459
62460   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62461   {
62462     try {
62463       delete arg1;
62464     } catch (std::out_of_range& e) {
62465       {
62466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62467       };
62468     } catch (std::exception& e) {
62469       {
62470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62471       };
62472     } catch (...) {
62473       {
62474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62475       };
62476     }
62477   }
62478 }
62479
62480
62481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62482   void * jresult ;
62483   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62484
62485   {
62486     try {
62487       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62488     } catch (std::out_of_range& e) {
62489       {
62490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62491       };
62492     } catch (std::exception& e) {
62493       {
62494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62495       };
62496     } catch (...) {
62497       {
62498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62499       };
62500     }
62501   }
62502   jresult = (void *)result;
62503   return jresult;
62504 }
62505
62506
62507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62508   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62509
62510   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62511   {
62512     try {
62513       delete arg1;
62514     } catch (std::out_of_range& e) {
62515       {
62516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62517       };
62518     } catch (std::exception& e) {
62519       {
62520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62521       };
62522     } catch (...) {
62523       {
62524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62525       };
62526     }
62527   }
62528 }
62529
62530
62531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62532   void * jresult ;
62533   Dali::Toolkit::Control result;
62534
62535   {
62536     try {
62537       result = Dali::Toolkit::Control::New();
62538     } catch (std::out_of_range& e) {
62539       {
62540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62541       };
62542     } catch (std::exception& e) {
62543       {
62544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62545       };
62546     } catch (...) {
62547       {
62548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62549       };
62550     }
62551   }
62552   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62553   return jresult;
62554 }
62555
62556
62557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62558   void * jresult ;
62559   Dali::Toolkit::Control *result = 0 ;
62560
62561   {
62562     try {
62563       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62564     } catch (std::out_of_range& e) {
62565       {
62566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62567       };
62568     } catch (std::exception& e) {
62569       {
62570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62571       };
62572     } catch (...) {
62573       {
62574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62575       };
62576     }
62577   }
62578   jresult = (void *)result;
62579   return jresult;
62580 }
62581
62582
62583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
62584   void * jresult ;
62585   Dali::Toolkit::Control *arg1 = 0 ;
62586   Dali::Toolkit::Control *result = 0 ;
62587
62588   arg1 = (Dali::Toolkit::Control *)jarg1;
62589   if (!arg1) {
62590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62591     return 0;
62592   }
62593   {
62594     try {
62595       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62596     } catch (std::out_of_range& e) {
62597       {
62598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62599       };
62600     } catch (std::exception& e) {
62601       {
62602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62603       };
62604     } catch (...) {
62605       {
62606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62607       };
62608     }
62609   }
62610   jresult = (void *)result;
62611   return jresult;
62612 }
62613
62614
62615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62616   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62617
62618   arg1 = (Dali::Toolkit::Control *)jarg1;
62619   {
62620     try {
62621       delete arg1;
62622     } catch (std::out_of_range& e) {
62623       {
62624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62625       };
62626     } catch (std::exception& e) {
62627       {
62628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62629       };
62630     } catch (...) {
62631       {
62632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62633       };
62634     }
62635   }
62636 }
62637
62638
62639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
62640   void * jresult ;
62641   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62642   Dali::Toolkit::Control *arg2 = 0 ;
62643   Dali::Toolkit::Control *result = 0 ;
62644
62645   arg1 = (Dali::Toolkit::Control *)jarg1;
62646   arg2 = (Dali::Toolkit::Control *)jarg2;
62647   if (!arg2) {
62648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62649     return 0;
62650   }
62651   {
62652     try {
62653       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
62654     } catch (std::out_of_range& e) {
62655       {
62656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62657       };
62658     } catch (std::exception& e) {
62659       {
62660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62661       };
62662     } catch (...) {
62663       {
62664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62665       };
62666     }
62667   }
62668   jresult = (void *)result;
62669   return jresult;
62670 }
62671
62672
62673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
62674   void * jresult ;
62675   Dali::BaseHandle arg1 ;
62676   Dali::BaseHandle *argp1 ;
62677   Dali::Toolkit::Control result;
62678
62679   argp1 = (Dali::BaseHandle *)jarg1;
62680   if (!argp1) {
62681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62682     return 0;
62683   }
62684   arg1 = *argp1;
62685   {
62686     try {
62687       result = Dali::Toolkit::Control::DownCast(arg1);
62688     } catch (std::out_of_range& e) {
62689       {
62690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62691       };
62692     } catch (std::exception& e) {
62693       {
62694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62695       };
62696     } catch (...) {
62697       {
62698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62699       };
62700     }
62701   }
62702   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62703   return jresult;
62704 }
62705
62706
62707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
62708   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62709
62710   arg1 = (Dali::Toolkit::Control *)jarg1;
62711   {
62712     try {
62713       (arg1)->SetKeyInputFocus();
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 unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
62732   unsigned int jresult ;
62733   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62734   bool result;
62735
62736   arg1 = (Dali::Toolkit::Control *)jarg1;
62737   {
62738     try {
62739       result = (bool)(arg1)->HasKeyInputFocus();
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 = result;
62755   return jresult;
62756 }
62757
62758
62759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
62760   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62761
62762   arg1 = (Dali::Toolkit::Control *)jarg1;
62763   {
62764     try {
62765       (arg1)->ClearKeyInputFocus();
62766     } catch (std::out_of_range& e) {
62767       {
62768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62769       };
62770     } catch (std::exception& e) {
62771       {
62772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62773       };
62774     } catch (...) {
62775       {
62776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62777       };
62778     }
62779   }
62780 }
62781
62782
62783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
62784   void * jresult ;
62785   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62786   Dali::PinchGestureDetector result;
62787
62788   arg1 = (Dali::Toolkit::Control *)jarg1;
62789   {
62790     try {
62791       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
62792     } catch (std::out_of_range& e) {
62793       {
62794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62795       };
62796     } catch (std::exception& e) {
62797       {
62798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62799       };
62800     } catch (...) {
62801       {
62802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62803       };
62804     }
62805   }
62806   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
62807   return jresult;
62808 }
62809
62810
62811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
62812   void * jresult ;
62813   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62814   Dali::PanGestureDetector result;
62815
62816   arg1 = (Dali::Toolkit::Control *)jarg1;
62817   {
62818     try {
62819       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
62820     } catch (std::out_of_range& e) {
62821       {
62822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62823       };
62824     } catch (std::exception& e) {
62825       {
62826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62827       };
62828     } catch (...) {
62829       {
62830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62831       };
62832     }
62833   }
62834   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
62835   return jresult;
62836 }
62837
62838
62839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
62840   void * jresult ;
62841   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62842   Dali::TapGestureDetector result;
62843
62844   arg1 = (Dali::Toolkit::Control *)jarg1;
62845   {
62846     try {
62847       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
62848     } catch (std::out_of_range& e) {
62849       {
62850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62851       };
62852     } catch (std::exception& e) {
62853       {
62854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62855       };
62856     } catch (...) {
62857       {
62858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62859       };
62860     }
62861   }
62862   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
62863   return jresult;
62864 }
62865
62866
62867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
62868   void * jresult ;
62869   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62870   Dali::LongPressGestureDetector result;
62871
62872   arg1 = (Dali::Toolkit::Control *)jarg1;
62873   {
62874     try {
62875       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
62876     } catch (std::out_of_range& e) {
62877       {
62878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62879       };
62880     } catch (std::exception& e) {
62881       {
62882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62883       };
62884     } catch (...) {
62885       {
62886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62887       };
62888     }
62889   }
62890   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
62891   return jresult;
62892 }
62893
62894
62895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
62896   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62897   std::string *arg2 = 0 ;
62898
62899   arg1 = (Dali::Toolkit::Control *)jarg1;
62900   if (!jarg2) {
62901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62902     return ;
62903   }
62904   std::string arg2_str(jarg2);
62905   arg2 = &arg2_str;
62906   {
62907     try {
62908       (arg1)->SetStyleName((std::string const &)*arg2);
62909     } catch (std::out_of_range& e) {
62910       {
62911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62912       };
62913     } catch (std::exception& e) {
62914       {
62915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62916       };
62917     } catch (...) {
62918       {
62919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62920       };
62921     }
62922   }
62923
62924   //argout typemap for const std::string&
62925
62926 }
62927
62928
62929 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
62930   char * jresult ;
62931   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62932   std::string *result = 0 ;
62933
62934   arg1 = (Dali::Toolkit::Control *)jarg1;
62935   {
62936     try {
62937       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
62938     } catch (std::out_of_range& e) {
62939       {
62940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62941       };
62942     } catch (std::exception& e) {
62943       {
62944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62945       };
62946     } catch (...) {
62947       {
62948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62949       };
62950     }
62951   }
62952   jresult = SWIG_csharp_string_callback(result->c_str());
62953   return jresult;
62954 }
62955
62956
62957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
62958   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62959   Dali::Vector4 *arg2 = 0 ;
62960
62961   arg1 = (Dali::Toolkit::Control *)jarg1;
62962   arg2 = (Dali::Vector4 *)jarg2;
62963   if (!arg2) {
62964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
62965     return ;
62966   }
62967   {
62968     try {
62969       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
62970     } catch (std::out_of_range& e) {
62971       {
62972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62973       };
62974     } catch (std::exception& e) {
62975       {
62976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62977       };
62978     } catch (...) {
62979       {
62980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62981       };
62982     }
62983   }
62984 }
62985
62986
62987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
62988   void * jresult ;
62989   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62990   Dali::Vector4 result;
62991
62992   arg1 = (Dali::Toolkit::Control *)jarg1;
62993   {
62994     try {
62995       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
62996     } catch (std::out_of_range& e) {
62997       {
62998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62999       };
63000     } catch (std::exception& e) {
63001       {
63002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63003       };
63004     } catch (...) {
63005       {
63006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63007       };
63008     }
63009   }
63010   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63011   return jresult;
63012 }
63013
63014
63015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
63016   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63017   Dali::Image arg2 ;
63018   Dali::Image *argp2 ;
63019
63020   arg1 = (Dali::Toolkit::Control *)jarg1;
63021   argp2 = (Dali::Image *)jarg2;
63022   if (!argp2) {
63023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63024     return ;
63025   }
63026   arg2 = *argp2;
63027   {
63028     try {
63029       (arg1)->SetBackgroundImage(arg2);
63030     } catch (std::out_of_range& e) {
63031       {
63032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63033       };
63034     } catch (std::exception& e) {
63035       {
63036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63037       };
63038     } catch (...) {
63039       {
63040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63041       };
63042     }
63043   }
63044 }
63045
63046
63047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63048   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63049
63050   arg1 = (Dali::Toolkit::Control *)jarg1;
63051   {
63052     try {
63053       (arg1)->ClearBackground();
63054     } catch (std::out_of_range& e) {
63055       {
63056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63057       };
63058     } catch (std::exception& e) {
63059       {
63060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63061       };
63062     } catch (...) {
63063       {
63064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63065       };
63066     }
63067   }
63068 }
63069
63070
63071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63072   void * jresult ;
63073   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63074   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63075
63076   arg1 = (Dali::Toolkit::Control *)jarg1;
63077   {
63078     try {
63079       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63080     } catch (std::out_of_range& e) {
63081       {
63082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63083       };
63084     } catch (std::exception& e) {
63085       {
63086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63087       };
63088     } catch (...) {
63089       {
63090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63091       };
63092     }
63093   }
63094   jresult = (void *)result;
63095   return jresult;
63096 }
63097
63098
63099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63100   void * jresult ;
63101   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63102   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63103
63104   arg1 = (Dali::Toolkit::Control *)jarg1;
63105   {
63106     try {
63107       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63108     } catch (std::out_of_range& e) {
63109       {
63110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63111       };
63112     } catch (std::exception& e) {
63113       {
63114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63115       };
63116     } catch (...) {
63117       {
63118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63119       };
63120     }
63121   }
63122   jresult = (void *)result;
63123   return jresult;
63124 }
63125
63126
63127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63128   void * jresult ;
63129   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63130   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63131
63132   arg1 = (Dali::Toolkit::Control *)jarg1;
63133   {
63134     try {
63135       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63136     } catch (std::out_of_range& e) {
63137       {
63138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63139       };
63140     } catch (std::exception& e) {
63141       {
63142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63143       };
63144     } catch (...) {
63145       {
63146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63147       };
63148     }
63149   }
63150   jresult = (void *)result;
63151   return jresult;
63152 }
63153
63154
63155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63156   void * jresult ;
63157   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63158   Dali::Toolkit::Control *result = 0 ;
63159
63160   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63161   if (!arg1) {
63162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63163     return 0;
63164   }
63165   {
63166     try {
63167       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63168     } catch (std::out_of_range& e) {
63169       {
63170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63171       };
63172     } catch (std::exception& e) {
63173       {
63174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63175       };
63176     } catch (...) {
63177       {
63178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63179       };
63180     }
63181   }
63182   jresult = (void *)result;
63183   return jresult;
63184 }
63185
63186
63187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63188   void * jresult ;
63189   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63190
63191   {
63192     try {
63193       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63194     } catch (std::out_of_range& e) {
63195       {
63196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63197       };
63198     } catch (std::exception& e) {
63199       {
63200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63201       };
63202     } catch (...) {
63203       {
63204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63205       };
63206     }
63207   }
63208   jresult = (void *)result;
63209   return jresult;
63210 }
63211
63212
63213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63214   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63215
63216   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63217   {
63218     try {
63219       delete arg1;
63220     } catch (std::out_of_range& e) {
63221       {
63222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63223       };
63224     } catch (std::exception& e) {
63225       {
63226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63227       };
63228     } catch (...) {
63229       {
63230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63231       };
63232     }
63233   }
63234 }
63235
63236
63237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63238   void * jresult ;
63239   Dali::Toolkit::KeyInputFocusManager result;
63240
63241   {
63242     try {
63243       result = Dali::Toolkit::KeyInputFocusManager::Get();
63244     } catch (std::out_of_range& e) {
63245       {
63246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63247       };
63248     } catch (std::exception& e) {
63249       {
63250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63251       };
63252     } catch (...) {
63253       {
63254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63255       };
63256     }
63257   }
63258   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63259   return jresult;
63260 }
63261
63262
63263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63264   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63265   Dali::Toolkit::Control arg2 ;
63266   Dali::Toolkit::Control *argp2 ;
63267
63268   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63269   argp2 = (Dali::Toolkit::Control *)jarg2;
63270   if (!argp2) {
63271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63272     return ;
63273   }
63274   arg2 = *argp2;
63275   {
63276     try {
63277       (arg1)->SetFocus(arg2);
63278     } catch (std::out_of_range& e) {
63279       {
63280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63281       };
63282     } catch (std::exception& e) {
63283       {
63284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63285       };
63286     } catch (...) {
63287       {
63288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63289       };
63290     }
63291   }
63292 }
63293
63294
63295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63296   void * jresult ;
63297   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63298   Dali::Toolkit::Control result;
63299
63300   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63301   {
63302     try {
63303       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63304     } catch (std::out_of_range& e) {
63305       {
63306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63307       };
63308     } catch (std::exception& e) {
63309       {
63310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63311       };
63312     } catch (...) {
63313       {
63314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63315       };
63316     }
63317   }
63318   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63319   return jresult;
63320 }
63321
63322
63323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
63324   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63325   Dali::Toolkit::Control arg2 ;
63326   Dali::Toolkit::Control *argp2 ;
63327
63328   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63329   argp2 = (Dali::Toolkit::Control *)jarg2;
63330   if (!argp2) {
63331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63332     return ;
63333   }
63334   arg2 = *argp2;
63335   {
63336     try {
63337       (arg1)->RemoveFocus(arg2);
63338     } catch (std::out_of_range& e) {
63339       {
63340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63341       };
63342     } catch (std::exception& e) {
63343       {
63344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63345       };
63346     } catch (...) {
63347       {
63348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63349       };
63350     }
63351   }
63352 }
63353
63354
63355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
63356   void * jresult ;
63357   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63358   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
63359
63360   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63361   {
63362     try {
63363       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
63364     } catch (std::out_of_range& e) {
63365       {
63366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63367       };
63368     } catch (std::exception& e) {
63369       {
63370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63371       };
63372     } catch (...) {
63373       {
63374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63375       };
63376     }
63377   }
63378   jresult = (void *)result;
63379   return jresult;
63380 }
63381
63382
63383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
63384   void * jresult ;
63385   Dali::Toolkit::Alignment::Padding *result = 0 ;
63386
63387   {
63388     try {
63389       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
63390     } catch (std::out_of_range& e) {
63391       {
63392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63393       };
63394     } catch (std::exception& e) {
63395       {
63396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63397       };
63398     } catch (...) {
63399       {
63400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63401       };
63402     }
63403   }
63404   jresult = (void *)result;
63405   return jresult;
63406 }
63407
63408
63409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
63410   void * jresult ;
63411   float arg1 ;
63412   float arg2 ;
63413   float arg3 ;
63414   float arg4 ;
63415   Dali::Toolkit::Alignment::Padding *result = 0 ;
63416
63417   arg1 = (float)jarg1;
63418   arg2 = (float)jarg2;
63419   arg3 = (float)jarg3;
63420   arg4 = (float)jarg4;
63421   {
63422     try {
63423       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
63424     } catch (std::out_of_range& e) {
63425       {
63426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63427       };
63428     } catch (std::exception& e) {
63429       {
63430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63431       };
63432     } catch (...) {
63433       {
63434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63435       };
63436     }
63437   }
63438   jresult = (void *)result;
63439   return jresult;
63440 }
63441
63442
63443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
63444   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63445   float arg2 ;
63446
63447   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63448   arg2 = (float)jarg2;
63449   if (arg1) (arg1)->left = arg2;
63450 }
63451
63452
63453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
63454   float jresult ;
63455   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63456   float result;
63457
63458   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63459   result = (float) ((arg1)->left);
63460   jresult = result;
63461   return jresult;
63462 }
63463
63464
63465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
63466   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63467   float arg2 ;
63468
63469   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63470   arg2 = (float)jarg2;
63471   if (arg1) (arg1)->right = arg2;
63472 }
63473
63474
63475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
63476   float jresult ;
63477   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63478   float result;
63479
63480   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63481   result = (float) ((arg1)->right);
63482   jresult = result;
63483   return jresult;
63484 }
63485
63486
63487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
63488   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63489   float arg2 ;
63490
63491   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63492   arg2 = (float)jarg2;
63493   if (arg1) (arg1)->top = arg2;
63494 }
63495
63496
63497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
63498   float jresult ;
63499   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63500   float result;
63501
63502   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63503   result = (float) ((arg1)->top);
63504   jresult = result;
63505   return jresult;
63506 }
63507
63508
63509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
63510   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63511   float arg2 ;
63512
63513   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63514   arg2 = (float)jarg2;
63515   if (arg1) (arg1)->bottom = arg2;
63516 }
63517
63518
63519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
63520   float jresult ;
63521   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63522   float result;
63523
63524   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63525   result = (float) ((arg1)->bottom);
63526   jresult = result;
63527   return jresult;
63528 }
63529
63530
63531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
63532   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63533
63534   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63535   {
63536     try {
63537       delete arg1;
63538     } catch (std::out_of_range& e) {
63539       {
63540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63541       };
63542     } catch (std::exception& e) {
63543       {
63544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63545       };
63546     } catch (...) {
63547       {
63548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63549       };
63550     }
63551   }
63552 }
63553
63554
63555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
63556   void * jresult ;
63557   Dali::Toolkit::Alignment *result = 0 ;
63558
63559   {
63560     try {
63561       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
63562     } catch (std::out_of_range& e) {
63563       {
63564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63565       };
63566     } catch (std::exception& e) {
63567       {
63568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63569       };
63570     } catch (...) {
63571       {
63572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63573       };
63574     }
63575   }
63576   jresult = (void *)result;
63577   return jresult;
63578 }
63579
63580
63581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
63582   void * jresult ;
63583   Dali::Toolkit::Alignment::Type arg1 ;
63584   Dali::Toolkit::Alignment::Type arg2 ;
63585   Dali::Toolkit::Alignment result;
63586
63587   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63588   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63589   {
63590     try {
63591       result = Dali::Toolkit::Alignment::New(arg1,arg2);
63592     } catch (std::out_of_range& e) {
63593       {
63594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63595       };
63596     } catch (std::exception& e) {
63597       {
63598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63599       };
63600     } catch (...) {
63601       {
63602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63603       };
63604     }
63605   }
63606   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63607   return jresult;
63608 }
63609
63610
63611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
63612   void * jresult ;
63613   Dali::Toolkit::Alignment::Type arg1 ;
63614   Dali::Toolkit::Alignment result;
63615
63616   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
63617   {
63618     try {
63619       result = Dali::Toolkit::Alignment::New(arg1);
63620     } catch (std::out_of_range& e) {
63621       {
63622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63623       };
63624     } catch (std::exception& e) {
63625       {
63626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63627       };
63628     } catch (...) {
63629       {
63630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63631       };
63632     }
63633   }
63634   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63635   return jresult;
63636 }
63637
63638
63639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
63640   void * jresult ;
63641   Dali::Toolkit::Alignment result;
63642
63643   {
63644     try {
63645       result = Dali::Toolkit::Alignment::New();
63646     } catch (std::out_of_range& e) {
63647       {
63648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63649       };
63650     } catch (std::exception& e) {
63651       {
63652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63653       };
63654     } catch (...) {
63655       {
63656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63657       };
63658     }
63659   }
63660   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63661   return jresult;
63662 }
63663
63664
63665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
63666   void * jresult ;
63667   Dali::Toolkit::Alignment *arg1 = 0 ;
63668   Dali::Toolkit::Alignment *result = 0 ;
63669
63670   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63671   if (!arg1) {
63672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63673     return 0;
63674   }
63675   {
63676     try {
63677       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
63678     } catch (std::out_of_range& e) {
63679       {
63680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63681       };
63682     } catch (std::exception& e) {
63683       {
63684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63685       };
63686     } catch (...) {
63687       {
63688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63689       };
63690     }
63691   }
63692   jresult = (void *)result;
63693   return jresult;
63694 }
63695
63696
63697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
63698   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63699
63700   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63701   {
63702     try {
63703       delete arg1;
63704     } catch (std::out_of_range& e) {
63705       {
63706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63707       };
63708     } catch (std::exception& e) {
63709       {
63710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63711       };
63712     } catch (...) {
63713       {
63714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63715       };
63716     }
63717   }
63718 }
63719
63720
63721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
63722   void * jresult ;
63723   Dali::BaseHandle arg1 ;
63724   Dali::BaseHandle *argp1 ;
63725   Dali::Toolkit::Alignment result;
63726
63727   argp1 = (Dali::BaseHandle *)jarg1;
63728   if (!argp1) {
63729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63730     return 0;
63731   }
63732   arg1 = *argp1;
63733   {
63734     try {
63735       result = Dali::Toolkit::Alignment::DownCast(arg1);
63736     } catch (std::out_of_range& e) {
63737       {
63738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63739       };
63740     } catch (std::exception& e) {
63741       {
63742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63743       };
63744     } catch (...) {
63745       {
63746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63747       };
63748     }
63749   }
63750   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
63751   return jresult;
63752 }
63753
63754
63755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
63756   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63757   Dali::Toolkit::Alignment::Type arg2 ;
63758
63759   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63760   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
63761   {
63762     try {
63763       (arg1)->SetAlignmentType(arg2);
63764     } catch (std::out_of_range& e) {
63765       {
63766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63767       };
63768     } catch (std::exception& e) {
63769       {
63770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63771       };
63772     } catch (...) {
63773       {
63774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63775       };
63776     }
63777   }
63778 }
63779
63780
63781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
63782   int jresult ;
63783   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63784   Dali::Toolkit::Alignment::Type result;
63785
63786   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63787   {
63788     try {
63789       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
63790     } catch (std::out_of_range& e) {
63791       {
63792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63793       };
63794     } catch (std::exception& e) {
63795       {
63796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63797       };
63798     } catch (...) {
63799       {
63800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63801       };
63802     }
63803   }
63804   jresult = (int)result;
63805   return jresult;
63806 }
63807
63808
63809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
63810   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63811   Dali::Toolkit::Alignment::Scaling arg2 ;
63812
63813   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63814   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
63815   {
63816     try {
63817       (arg1)->SetScaling(arg2);
63818     } catch (std::out_of_range& e) {
63819       {
63820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63821       };
63822     } catch (std::exception& e) {
63823       {
63824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63825       };
63826     } catch (...) {
63827       {
63828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63829       };
63830     }
63831   }
63832 }
63833
63834
63835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
63836   int jresult ;
63837   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63838   Dali::Toolkit::Alignment::Scaling result;
63839
63840   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63841   {
63842     try {
63843       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
63844     } catch (std::out_of_range& e) {
63845       {
63846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63847       };
63848     } catch (std::exception& e) {
63849       {
63850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63851       };
63852     } catch (...) {
63853       {
63854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63855       };
63856     }
63857   }
63858   jresult = (int)result;
63859   return jresult;
63860 }
63861
63862
63863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
63864   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63865   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
63866
63867   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63868   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
63869   if (!arg2) {
63870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
63871     return ;
63872   }
63873   {
63874     try {
63875       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
63876     } catch (std::out_of_range& e) {
63877       {
63878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63879       };
63880     } catch (std::exception& e) {
63881       {
63882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63883       };
63884     } catch (...) {
63885       {
63886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63887       };
63888     }
63889   }
63890 }
63891
63892
63893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
63894   void * jresult ;
63895   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63896   Dali::Toolkit::Alignment::Padding *result = 0 ;
63897
63898   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63899   {
63900     try {
63901       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
63902     } catch (std::out_of_range& e) {
63903       {
63904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63905       };
63906     } catch (std::exception& e) {
63907       {
63908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63909       };
63910     } catch (...) {
63911       {
63912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63913       };
63914     }
63915   }
63916   jresult = (void *)result;
63917   return jresult;
63918 }
63919
63920
63921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
63922   void * jresult ;
63923   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
63924   Dali::Toolkit::Alignment *arg2 = 0 ;
63925   Dali::Toolkit::Alignment *result = 0 ;
63926
63927   arg1 = (Dali::Toolkit::Alignment *)jarg1;
63928   arg2 = (Dali::Toolkit::Alignment *)jarg2;
63929   if (!arg2) {
63930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
63931     return 0;
63932   }
63933   {
63934     try {
63935       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
63936     } catch (std::out_of_range& e) {
63937       {
63938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63939       };
63940     } catch (std::exception& e) {
63941       {
63942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63943       };
63944     } catch (...) {
63945       {
63946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63947       };
63948     }
63949   }
63950   jresult = (void *)result;
63951   return jresult;
63952 }
63953
63954
63955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
63956   int jresult ;
63957   int result;
63958
63959   result = (int)Dali::Toolkit::Button::Property::DISABLED;
63960   jresult = (int)result;
63961   return jresult;
63962 }
63963
63964
63965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
63966   int jresult ;
63967   int result;
63968
63969   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
63970   jresult = (int)result;
63971   return jresult;
63972 }
63973
63974
63975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
63976   int jresult ;
63977   int result;
63978
63979   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
63980   jresult = (int)result;
63981   return jresult;
63982 }
63983
63984
63985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
63986   int jresult ;
63987   int result;
63988
63989   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
63990   jresult = (int)result;
63991   return jresult;
63992 }
63993
63994
63995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
63996   int jresult ;
63997   int result;
63998
63999   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64000   jresult = (int)result;
64001   return jresult;
64002 }
64003
64004
64005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64006   int jresult ;
64007   int result;
64008
64009   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64010   jresult = (int)result;
64011   return jresult;
64012 }
64013
64014
64015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
64016   int jresult ;
64017   int result;
64018
64019   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
64020   jresult = (int)result;
64021   return jresult;
64022 }
64023
64024
64025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
64026   int jresult ;
64027   int result;
64028
64029   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
64030   jresult = (int)result;
64031   return jresult;
64032 }
64033
64034
64035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64036   int jresult ;
64037   int result;
64038
64039   result = (int)Dali::Toolkit::Button::Property::LABEL;
64040   jresult = (int)result;
64041   return jresult;
64042 }
64043
64044
64045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
64046   int jresult ;
64047   int result;
64048
64049   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
64050   jresult = (int)result;
64051   return jresult;
64052 }
64053
64054
64055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64056   void * jresult ;
64057   Dali::Toolkit::Button::Property *result = 0 ;
64058
64059   {
64060     try {
64061       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64062     } catch (std::out_of_range& e) {
64063       {
64064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64065       };
64066     } catch (std::exception& e) {
64067       {
64068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64069       };
64070     } catch (...) {
64071       {
64072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64073       };
64074     }
64075   }
64076   jresult = (void *)result;
64077   return jresult;
64078 }
64079
64080
64081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64082   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64083
64084   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64085   {
64086     try {
64087       delete arg1;
64088     } catch (std::out_of_range& e) {
64089       {
64090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64091       };
64092     } catch (std::exception& e) {
64093       {
64094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64095       };
64096     } catch (...) {
64097       {
64098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64099       };
64100     }
64101   }
64102 }
64103
64104
64105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
64106   void * jresult ;
64107   Dali::Toolkit::Button *result = 0 ;
64108
64109   {
64110     try {
64111       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64112     } catch (std::out_of_range& e) {
64113       {
64114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64115       };
64116     } catch (std::exception& e) {
64117       {
64118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64119       };
64120     } catch (...) {
64121       {
64122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64123       };
64124     }
64125   }
64126   jresult = (void *)result;
64127   return jresult;
64128 }
64129
64130
64131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64132   void * jresult ;
64133   Dali::Toolkit::Button *arg1 = 0 ;
64134   Dali::Toolkit::Button *result = 0 ;
64135
64136   arg1 = (Dali::Toolkit::Button *)jarg1;
64137   if (!arg1) {
64138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64139     return 0;
64140   }
64141   {
64142     try {
64143       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64144     } catch (std::out_of_range& e) {
64145       {
64146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64147       };
64148     } catch (std::exception& e) {
64149       {
64150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64151       };
64152     } catch (...) {
64153       {
64154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64155       };
64156     }
64157   }
64158   jresult = (void *)result;
64159   return jresult;
64160 }
64161
64162
64163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64164   void * jresult ;
64165   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64166   Dali::Toolkit::Button *arg2 = 0 ;
64167   Dali::Toolkit::Button *result = 0 ;
64168
64169   arg1 = (Dali::Toolkit::Button *)jarg1;
64170   arg2 = (Dali::Toolkit::Button *)jarg2;
64171   if (!arg2) {
64172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64173     return 0;
64174   }
64175   {
64176     try {
64177       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64178     } catch (std::out_of_range& e) {
64179       {
64180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64181       };
64182     } catch (std::exception& e) {
64183       {
64184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64185       };
64186     } catch (...) {
64187       {
64188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64189       };
64190     }
64191   }
64192   jresult = (void *)result;
64193   return jresult;
64194 }
64195
64196
64197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
64198   void * jresult ;
64199   Dali::BaseHandle arg1 ;
64200   Dali::BaseHandle *argp1 ;
64201   Dali::Toolkit::Button result;
64202
64203   argp1 = (Dali::BaseHandle *)jarg1;
64204   if (!argp1) {
64205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64206     return 0;
64207   }
64208   arg1 = *argp1;
64209   {
64210     try {
64211       result = Dali::Toolkit::Button::DownCast(arg1);
64212     } catch (std::out_of_range& e) {
64213       {
64214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64215       };
64216     } catch (std::exception& e) {
64217       {
64218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64219       };
64220     } catch (...) {
64221       {
64222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64223       };
64224     }
64225   }
64226   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
64227   return jresult;
64228 }
64229
64230
64231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
64232   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64233
64234   arg1 = (Dali::Toolkit::Button *)jarg1;
64235   {
64236     try {
64237       delete arg1;
64238     } catch (std::out_of_range& e) {
64239       {
64240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64241       };
64242     } catch (std::exception& e) {
64243       {
64244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64245       };
64246     } catch (...) {
64247       {
64248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64249       };
64250     }
64251   }
64252 }
64253
64254
64255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
64256   unsigned int jresult ;
64257   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64258   bool result;
64259
64260   arg1 = (Dali::Toolkit::Button *)jarg1;
64261   {
64262     try {
64263       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
64264     } catch (std::out_of_range& e) {
64265       {
64266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64267       };
64268     } catch (std::exception& e) {
64269       {
64270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64271       };
64272     } catch (...) {
64273       {
64274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64275       };
64276     }
64277   }
64278   jresult = result;
64279   return jresult;
64280 }
64281
64282
64283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
64284   unsigned int jresult ;
64285   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64286   bool result;
64287
64288   arg1 = (Dali::Toolkit::Button *)jarg1;
64289   {
64290     try {
64291       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
64292     } catch (std::out_of_range& e) {
64293       {
64294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64295       };
64296     } catch (std::exception& e) {
64297       {
64298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64299       };
64300     } catch (...) {
64301       {
64302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64303       };
64304     }
64305   }
64306   jresult = result;
64307   return jresult;
64308 }
64309
64310
64311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
64312   float jresult ;
64313   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64314   float result;
64315
64316   arg1 = (Dali::Toolkit::Button *)jarg1;
64317   {
64318     try {
64319       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
64320     } catch (std::out_of_range& e) {
64321       {
64322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64323       };
64324     } catch (std::exception& e) {
64325       {
64326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64327       };
64328     } catch (...) {
64329       {
64330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64331       };
64332     }
64333   }
64334   jresult = result;
64335   return jresult;
64336 }
64337
64338
64339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
64340   float jresult ;
64341   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64342   float result;
64343
64344   arg1 = (Dali::Toolkit::Button *)jarg1;
64345   {
64346     try {
64347       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
64348     } catch (std::out_of_range& e) {
64349       {
64350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64351       };
64352     } catch (std::exception& e) {
64353       {
64354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64355       };
64356     } catch (...) {
64357       {
64358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64359       };
64360     }
64361   }
64362   jresult = result;
64363   return jresult;
64364 }
64365
64366
64367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
64368   unsigned int jresult ;
64369   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64370   bool result;
64371
64372   arg1 = (Dali::Toolkit::Button *)jarg1;
64373   {
64374     try {
64375       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
64376     } catch (std::out_of_range& e) {
64377       {
64378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64379       };
64380     } catch (std::exception& e) {
64381       {
64382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64383       };
64384     } catch (...) {
64385       {
64386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64387       };
64388     }
64389   }
64390   jresult = result;
64391   return jresult;
64392 }
64393
64394
64395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
64396   unsigned int jresult ;
64397   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64398   bool result;
64399
64400   arg1 = (Dali::Toolkit::Button *)jarg1;
64401   {
64402     try {
64403       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
64404     } catch (std::out_of_range& e) {
64405       {
64406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64407       };
64408     } catch (std::exception& e) {
64409       {
64410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64411       };
64412     } catch (...) {
64413       {
64414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64415       };
64416     }
64417   }
64418   jresult = result;
64419   return jresult;
64420 }
64421
64422
64423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
64424   float jresult ;
64425   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64426   float result;
64427
64428   arg1 = (Dali::Toolkit::Button *)jarg1;
64429   {
64430     try {
64431       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
64432     } catch (std::out_of_range& e) {
64433       {
64434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64435       };
64436     } catch (std::exception& e) {
64437       {
64438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64439       };
64440     } catch (...) {
64441       {
64442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64443       };
64444     }
64445   }
64446   jresult = result;
64447   return jresult;
64448 }
64449
64450
64451 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
64452   char * jresult ;
64453   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64454   std::string result;
64455
64456   arg1 = (Dali::Toolkit::Button *)jarg1;
64457   {
64458     try {
64459       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
64460     } catch (std::out_of_range& e) {
64461       {
64462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64463       };
64464     } catch (std::exception& e) {
64465       {
64466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64467       };
64468     } catch (...) {
64469       {
64470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64471       };
64472     }
64473   }
64474   jresult = SWIG_csharp_string_callback((&result)->c_str());
64475   return jresult;
64476 }
64477
64478
64479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
64480   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64481   Dali::Actor arg2 ;
64482   Dali::Actor *argp2 ;
64483
64484   arg1 = (Dali::Toolkit::Button *)jarg1;
64485   argp2 = (Dali::Actor *)jarg2;
64486   if (!argp2) {
64487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64488     return ;
64489   }
64490   arg2 = *argp2;
64491   {
64492     try {
64493       (arg1)->SetLabel(arg2);
64494     } catch (std::out_of_range& e) {
64495       {
64496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64497       };
64498     } catch (std::exception& e) {
64499       {
64500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64501       };
64502     } catch (...) {
64503       {
64504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64505       };
64506     }
64507   }
64508 }
64509
64510
64511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
64512   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64513   Dali::Image arg2 ;
64514   Dali::Image *argp2 ;
64515
64516   arg1 = (Dali::Toolkit::Button *)jarg1;
64517   argp2 = (Dali::Image *)jarg2;
64518   if (!argp2) {
64519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64520     return ;
64521   }
64522   arg2 = *argp2;
64523   {
64524     try {
64525       (arg1)->SetButtonImage(arg2);
64526     } catch (std::out_of_range& e) {
64527       {
64528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64529       };
64530     } catch (std::exception& e) {
64531       {
64532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64533       };
64534     } catch (...) {
64535       {
64536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64537       };
64538     }
64539   }
64540 }
64541
64542
64543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
64544   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64545   Dali::Image arg2 ;
64546   Dali::Image *argp2 ;
64547
64548   arg1 = (Dali::Toolkit::Button *)jarg1;
64549   argp2 = (Dali::Image *)jarg2;
64550   if (!argp2) {
64551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
64552     return ;
64553   }
64554   arg2 = *argp2;
64555   {
64556     try {
64557       (arg1)->SetSelectedImage(arg2);
64558     } catch (std::out_of_range& e) {
64559       {
64560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64561       };
64562     } catch (std::exception& e) {
64563       {
64564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64565       };
64566     } catch (...) {
64567       {
64568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64569       };
64570     }
64571   }
64572 }
64573
64574
64575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
64576   void * jresult ;
64577   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64578   Dali::Actor result;
64579
64580   arg1 = (Dali::Toolkit::Button *)jarg1;
64581   {
64582     try {
64583       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
64584     } catch (std::out_of_range& e) {
64585       {
64586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64587       };
64588     } catch (std::exception& e) {
64589       {
64590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64591       };
64592     } catch (...) {
64593       {
64594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64595       };
64596     }
64597   }
64598   jresult = new Dali::Actor((const Dali::Actor &)result);
64599   return jresult;
64600 }
64601
64602
64603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
64604   void * jresult ;
64605   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64606   Dali::Actor result;
64607
64608   arg1 = (Dali::Toolkit::Button *)jarg1;
64609   {
64610     try {
64611       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
64612     } catch (std::out_of_range& e) {
64613       {
64614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64615       };
64616     } catch (std::exception& e) {
64617       {
64618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64619       };
64620     } catch (...) {
64621       {
64622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64623       };
64624     }
64625   }
64626   jresult = new Dali::Actor((const Dali::Actor &)result);
64627   return jresult;
64628 }
64629
64630
64631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64632   void * jresult ;
64633   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64634   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64635
64636   arg1 = (Dali::Toolkit::Button *)jarg1;
64637   {
64638     try {
64639       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64640     } catch (std::out_of_range& e) {
64641       {
64642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64643       };
64644     } catch (std::exception& e) {
64645       {
64646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64647       };
64648     } catch (...) {
64649       {
64650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64651       };
64652     }
64653   }
64654   jresult = (void *)result;
64655   return jresult;
64656 }
64657
64658
64659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64660   void * jresult ;
64661   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64662   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64663
64664   arg1 = (Dali::Toolkit::Button *)jarg1;
64665   {
64666     try {
64667       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
64668     } catch (std::out_of_range& e) {
64669       {
64670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64671       };
64672     } catch (std::exception& e) {
64673       {
64674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64675       };
64676     } catch (...) {
64677       {
64678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64679       };
64680     }
64681   }
64682   jresult = (void *)result;
64683   return jresult;
64684 }
64685
64686
64687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
64688   void * jresult ;
64689   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64690   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64691
64692   arg1 = (Dali::Toolkit::Button *)jarg1;
64693   {
64694     try {
64695       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
64696     } catch (std::out_of_range& e) {
64697       {
64698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64699       };
64700     } catch (std::exception& e) {
64701       {
64702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64703       };
64704     } catch (...) {
64705       {
64706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64707       };
64708     }
64709   }
64710   jresult = (void *)result;
64711   return jresult;
64712 }
64713
64714
64715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
64716   void * jresult ;
64717   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64718   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64719
64720   arg1 = (Dali::Toolkit::Button *)jarg1;
64721   {
64722     try {
64723       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
64724     } catch (std::out_of_range& e) {
64725       {
64726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64727       };
64728     } catch (std::exception& e) {
64729       {
64730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64731       };
64732     } catch (...) {
64733       {
64734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64735       };
64736     }
64737   }
64738   jresult = (void *)result;
64739   return jresult;
64740 }
64741
64742
64743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
64744   void * jresult ;
64745   Dali::Toolkit::CheckBoxButton *result = 0 ;
64746
64747   {
64748     try {
64749       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
64750     } catch (std::out_of_range& e) {
64751       {
64752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64753       };
64754     } catch (std::exception& e) {
64755       {
64756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64757       };
64758     } catch (...) {
64759       {
64760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64761       };
64762     }
64763   }
64764   jresult = (void *)result;
64765   return jresult;
64766 }
64767
64768
64769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
64770   void * jresult ;
64771   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
64772   Dali::Toolkit::CheckBoxButton *result = 0 ;
64773
64774   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64775   if (!arg1) {
64776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64777     return 0;
64778   }
64779   {
64780     try {
64781       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
64782     } catch (std::out_of_range& e) {
64783       {
64784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64785       };
64786     } catch (std::exception& e) {
64787       {
64788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64789       };
64790     } catch (...) {
64791       {
64792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64793       };
64794     }
64795   }
64796   jresult = (void *)result;
64797   return jresult;
64798 }
64799
64800
64801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
64802   void * jresult ;
64803   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64804   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
64805   Dali::Toolkit::CheckBoxButton *result = 0 ;
64806
64807   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64808   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
64809   if (!arg2) {
64810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
64811     return 0;
64812   }
64813   {
64814     try {
64815       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
64816     } catch (std::out_of_range& e) {
64817       {
64818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64819       };
64820     } catch (std::exception& e) {
64821       {
64822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64823       };
64824     } catch (...) {
64825       {
64826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64827       };
64828     }
64829   }
64830   jresult = (void *)result;
64831   return jresult;
64832 }
64833
64834
64835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
64836   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
64837
64838   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
64839   {
64840     try {
64841       delete arg1;
64842     } catch (std::out_of_range& e) {
64843       {
64844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64845       };
64846     } catch (std::exception& e) {
64847       {
64848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64849       };
64850     } catch (...) {
64851       {
64852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64853       };
64854     }
64855   }
64856 }
64857
64858
64859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
64860   void * jresult ;
64861   Dali::Toolkit::CheckBoxButton result;
64862
64863   {
64864     try {
64865       result = Dali::Toolkit::CheckBoxButton::New();
64866     } catch (std::out_of_range& e) {
64867       {
64868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64869       };
64870     } catch (std::exception& e) {
64871       {
64872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64873       };
64874     } catch (...) {
64875       {
64876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64877       };
64878     }
64879   }
64880   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64881   return jresult;
64882 }
64883
64884
64885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
64886   void * jresult ;
64887   Dali::BaseHandle arg1 ;
64888   Dali::BaseHandle *argp1 ;
64889   Dali::Toolkit::CheckBoxButton result;
64890
64891   argp1 = (Dali::BaseHandle *)jarg1;
64892   if (!argp1) {
64893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64894     return 0;
64895   }
64896   arg1 = *argp1;
64897   {
64898     try {
64899       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
64900     } catch (std::out_of_range& e) {
64901       {
64902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64903       };
64904     } catch (std::exception& e) {
64905       {
64906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64907       };
64908     } catch (...) {
64909       {
64910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64911       };
64912     }
64913   }
64914   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
64915   return jresult;
64916 }
64917
64918
64919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
64920   int jresult ;
64921   int result;
64922
64923   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
64924   jresult = (int)result;
64925   return jresult;
64926 }
64927
64928
64929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
64930   int jresult ;
64931   int result;
64932
64933   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
64934   jresult = (int)result;
64935   return jresult;
64936 }
64937
64938
64939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
64940   int jresult ;
64941   int result;
64942
64943   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
64944   jresult = (int)result;
64945   return jresult;
64946 }
64947
64948
64949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
64950   int jresult ;
64951   int result;
64952
64953   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
64954   jresult = (int)result;
64955   return jresult;
64956 }
64957
64958
64959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
64960   int jresult ;
64961   int result;
64962
64963   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
64964   jresult = (int)result;
64965   return jresult;
64966 }
64967
64968
64969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
64970   void * jresult ;
64971   Dali::Toolkit::PushButton::Property *result = 0 ;
64972
64973   {
64974     try {
64975       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
64976     } catch (std::out_of_range& e) {
64977       {
64978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64979       };
64980     } catch (std::exception& e) {
64981       {
64982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64983       };
64984     } catch (...) {
64985       {
64986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64987       };
64988     }
64989   }
64990   jresult = (void *)result;
64991   return jresult;
64992 }
64993
64994
64995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
64996   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
64997
64998   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
64999   {
65000     try {
65001       delete arg1;
65002     } catch (std::out_of_range& e) {
65003       {
65004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65005       };
65006     } catch (std::exception& e) {
65007       {
65008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65009       };
65010     } catch (...) {
65011       {
65012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65013       };
65014     }
65015   }
65016 }
65017
65018
65019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65020   void * jresult ;
65021   Dali::Toolkit::PushButton *result = 0 ;
65022
65023   {
65024     try {
65025       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65026     } catch (std::out_of_range& e) {
65027       {
65028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65029       };
65030     } catch (std::exception& e) {
65031       {
65032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65033       };
65034     } catch (...) {
65035       {
65036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65037       };
65038     }
65039   }
65040   jresult = (void *)result;
65041   return jresult;
65042 }
65043
65044
65045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65046   void * jresult ;
65047   Dali::Toolkit::PushButton *arg1 = 0 ;
65048   Dali::Toolkit::PushButton *result = 0 ;
65049
65050   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65051   if (!arg1) {
65052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65053     return 0;
65054   }
65055   {
65056     try {
65057       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65058     } catch (std::out_of_range& e) {
65059       {
65060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65061       };
65062     } catch (std::exception& e) {
65063       {
65064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65065       };
65066     } catch (...) {
65067       {
65068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65069       };
65070     }
65071   }
65072   jresult = (void *)result;
65073   return jresult;
65074 }
65075
65076
65077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65078   void * jresult ;
65079   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65080   Dali::Toolkit::PushButton *arg2 = 0 ;
65081   Dali::Toolkit::PushButton *result = 0 ;
65082
65083   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65084   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65085   if (!arg2) {
65086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65087     return 0;
65088   }
65089   {
65090     try {
65091       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65092     } catch (std::out_of_range& e) {
65093       {
65094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65095       };
65096     } catch (std::exception& e) {
65097       {
65098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65099       };
65100     } catch (...) {
65101       {
65102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65103       };
65104     }
65105   }
65106   jresult = (void *)result;
65107   return jresult;
65108 }
65109
65110
65111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65112   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65113
65114   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65115   {
65116     try {
65117       delete arg1;
65118     } catch (std::out_of_range& e) {
65119       {
65120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65121       };
65122     } catch (std::exception& e) {
65123       {
65124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65125       };
65126     } catch (...) {
65127       {
65128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65129       };
65130     }
65131   }
65132 }
65133
65134
65135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65136   void * jresult ;
65137   Dali::Toolkit::PushButton result;
65138
65139   {
65140     try {
65141       result = Dali::Toolkit::PushButton::New();
65142     } catch (std::out_of_range& e) {
65143       {
65144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65145       };
65146     } catch (std::exception& e) {
65147       {
65148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65149       };
65150     } catch (...) {
65151       {
65152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65153       };
65154     }
65155   }
65156   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65157   return jresult;
65158 }
65159
65160
65161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65162   void * jresult ;
65163   Dali::BaseHandle arg1 ;
65164   Dali::BaseHandle *argp1 ;
65165   Dali::Toolkit::PushButton result;
65166
65167   argp1 = (Dali::BaseHandle *)jarg1;
65168   if (!argp1) {
65169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65170     return 0;
65171   }
65172   arg1 = *argp1;
65173   {
65174     try {
65175       result = Dali::Toolkit::PushButton::DownCast(arg1);
65176     } catch (std::out_of_range& e) {
65177       {
65178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65179       };
65180     } catch (std::exception& e) {
65181       {
65182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65183       };
65184     } catch (...) {
65185       {
65186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65187       };
65188     }
65189   }
65190   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65191   return jresult;
65192 }
65193
65194
65195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
65196   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65197   Dali::Image arg2 ;
65198   Dali::Image *argp2 ;
65199
65200   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65201   argp2 = (Dali::Image *)jarg2;
65202   if (!argp2) {
65203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65204     return ;
65205   }
65206   arg2 = *argp2;
65207   {
65208     try {
65209       (arg1)->SetButtonImage(arg2);
65210     } catch (std::out_of_range& e) {
65211       {
65212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65213       };
65214     } catch (std::exception& e) {
65215       {
65216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65217       };
65218     } catch (...) {
65219       {
65220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65221       };
65222     }
65223   }
65224 }
65225
65226
65227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
65228   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65229   Dali::Actor arg2 ;
65230   Dali::Actor *argp2 ;
65231
65232   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65233   argp2 = (Dali::Actor *)jarg2;
65234   if (!argp2) {
65235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65236     return ;
65237   }
65238   arg2 = *argp2;
65239   {
65240     try {
65241       (arg1)->SetButtonImage(arg2);
65242     } catch (std::out_of_range& e) {
65243       {
65244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65245       };
65246     } catch (std::exception& e) {
65247       {
65248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65249       };
65250     } catch (...) {
65251       {
65252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65253       };
65254     }
65255   }
65256 }
65257
65258
65259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
65260   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65261   Dali::Actor arg2 ;
65262   Dali::Actor *argp2 ;
65263
65264   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65265   argp2 = (Dali::Actor *)jarg2;
65266   if (!argp2) {
65267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65268     return ;
65269   }
65270   arg2 = *argp2;
65271   {
65272     try {
65273       (arg1)->SetBackgroundImage(arg2);
65274     } catch (std::out_of_range& e) {
65275       {
65276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65277       };
65278     } catch (std::exception& e) {
65279       {
65280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65281       };
65282     } catch (...) {
65283       {
65284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65285       };
65286     }
65287   }
65288 }
65289
65290
65291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
65292   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65293   Dali::Image arg2 ;
65294   Dali::Image *argp2 ;
65295
65296   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65297   argp2 = (Dali::Image *)jarg2;
65298   if (!argp2) {
65299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
65300     return ;
65301   }
65302   arg2 = *argp2;
65303   {
65304     try {
65305       (arg1)->SetSelectedImage(arg2);
65306     } catch (std::out_of_range& e) {
65307       {
65308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65309       };
65310     } catch (std::exception& e) {
65311       {
65312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65313       };
65314     } catch (...) {
65315       {
65316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65317       };
65318     }
65319   }
65320 }
65321
65322
65323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
65324   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65325   Dali::Actor arg2 ;
65326   Dali::Actor *argp2 ;
65327
65328   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65329   argp2 = (Dali::Actor *)jarg2;
65330   if (!argp2) {
65331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65332     return ;
65333   }
65334   arg2 = *argp2;
65335   {
65336     try {
65337       (arg1)->SetSelectedImage(arg2);
65338     } catch (std::out_of_range& e) {
65339       {
65340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65341       };
65342     } catch (std::exception& e) {
65343       {
65344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65345       };
65346     } catch (...) {
65347       {
65348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65349       };
65350     }
65351   }
65352 }
65353
65354
65355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
65356   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65357   Dali::Actor arg2 ;
65358   Dali::Actor *argp2 ;
65359
65360   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65361   argp2 = (Dali::Actor *)jarg2;
65362   if (!argp2) {
65363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65364     return ;
65365   }
65366   arg2 = *argp2;
65367   {
65368     try {
65369       (arg1)->SetSelectedBackgroundImage(arg2);
65370     } catch (std::out_of_range& e) {
65371       {
65372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65373       };
65374     } catch (std::exception& e) {
65375       {
65376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65377       };
65378     } catch (...) {
65379       {
65380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65381       };
65382     }
65383   }
65384 }
65385
65386
65387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
65388   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65389   Dali::Actor arg2 ;
65390   Dali::Actor *argp2 ;
65391
65392   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65393   argp2 = (Dali::Actor *)jarg2;
65394   if (!argp2) {
65395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65396     return ;
65397   }
65398   arg2 = *argp2;
65399   {
65400     try {
65401       (arg1)->SetDisabledBackgroundImage(arg2);
65402     } catch (std::out_of_range& e) {
65403       {
65404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65405       };
65406     } catch (std::exception& e) {
65407       {
65408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65409       };
65410     } catch (...) {
65411       {
65412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65413       };
65414     }
65415   }
65416 }
65417
65418
65419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
65420   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65421   Dali::Actor arg2 ;
65422   Dali::Actor *argp2 ;
65423
65424   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65425   argp2 = (Dali::Actor *)jarg2;
65426   if (!argp2) {
65427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65428     return ;
65429   }
65430   arg2 = *argp2;
65431   {
65432     try {
65433       (arg1)->SetDisabledImage(arg2);
65434     } catch (std::out_of_range& e) {
65435       {
65436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65437       };
65438     } catch (std::exception& e) {
65439       {
65440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65441       };
65442     } catch (...) {
65443       {
65444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65445       };
65446     }
65447   }
65448 }
65449
65450
65451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
65452   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65453   Dali::Actor arg2 ;
65454   Dali::Actor *argp2 ;
65455
65456   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65457   argp2 = (Dali::Actor *)jarg2;
65458   if (!argp2) {
65459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65460     return ;
65461   }
65462   arg2 = *argp2;
65463   {
65464     try {
65465       (arg1)->SetDisabledSelectedImage(arg2);
65466     } catch (std::out_of_range& e) {
65467       {
65468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65469       };
65470     } catch (std::exception& e) {
65471       {
65472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65473       };
65474     } catch (...) {
65475       {
65476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65477       };
65478     }
65479   }
65480 }
65481
65482
65483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65484   void * jresult ;
65485   Dali::Toolkit::RadioButton *result = 0 ;
65486
65487   {
65488     try {
65489       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65490     } catch (std::out_of_range& e) {
65491       {
65492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65493       };
65494     } catch (std::exception& e) {
65495       {
65496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65497       };
65498     } catch (...) {
65499       {
65500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65501       };
65502     }
65503   }
65504   jresult = (void *)result;
65505   return jresult;
65506 }
65507
65508
65509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65510   void * jresult ;
65511   Dali::Toolkit::RadioButton *arg1 = 0 ;
65512   Dali::Toolkit::RadioButton *result = 0 ;
65513
65514   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65515   if (!arg1) {
65516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65517     return 0;
65518   }
65519   {
65520     try {
65521       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65522     } catch (std::out_of_range& e) {
65523       {
65524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65525       };
65526     } catch (std::exception& e) {
65527       {
65528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65529       };
65530     } catch (...) {
65531       {
65532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65533       };
65534     }
65535   }
65536   jresult = (void *)result;
65537   return jresult;
65538 }
65539
65540
65541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65542   void * jresult ;
65543   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65544   Dali::Toolkit::RadioButton *arg2 = 0 ;
65545   Dali::Toolkit::RadioButton *result = 0 ;
65546
65547   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65548   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65549   if (!arg2) {
65550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65551     return 0;
65552   }
65553   {
65554     try {
65555       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65556     } catch (std::out_of_range& e) {
65557       {
65558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65559       };
65560     } catch (std::exception& e) {
65561       {
65562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65563       };
65564     } catch (...) {
65565       {
65566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65567       };
65568     }
65569   }
65570   jresult = (void *)result;
65571   return jresult;
65572 }
65573
65574
65575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65576   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65577
65578   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65579   {
65580     try {
65581       delete arg1;
65582     } catch (std::out_of_range& e) {
65583       {
65584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65585       };
65586     } catch (std::exception& e) {
65587       {
65588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65589       };
65590     } catch (...) {
65591       {
65592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65593       };
65594     }
65595   }
65596 }
65597
65598
65599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65600   void * jresult ;
65601   Dali::Toolkit::RadioButton result;
65602
65603   {
65604     try {
65605       result = Dali::Toolkit::RadioButton::New();
65606     } catch (std::out_of_range& e) {
65607       {
65608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65609       };
65610     } catch (std::exception& e) {
65611       {
65612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65613       };
65614     } catch (...) {
65615       {
65616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65617       };
65618     }
65619   }
65620   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65621   return jresult;
65622 }
65623
65624
65625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65626   void * jresult ;
65627   std::string *arg1 = 0 ;
65628   Dali::Toolkit::RadioButton result;
65629
65630   if (!jarg1) {
65631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65632     return 0;
65633   }
65634   std::string arg1_str(jarg1);
65635   arg1 = &arg1_str;
65636   {
65637     try {
65638       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65639     } catch (std::out_of_range& e) {
65640       {
65641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65642       };
65643     } catch (std::exception& e) {
65644       {
65645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65646       };
65647     } catch (...) {
65648       {
65649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65650       };
65651     }
65652   }
65653   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65654
65655   //argout typemap for const std::string&
65656
65657   return jresult;
65658 }
65659
65660
65661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65662   void * jresult ;
65663   Dali::BaseHandle arg1 ;
65664   Dali::BaseHandle *argp1 ;
65665   Dali::Toolkit::RadioButton result;
65666
65667   argp1 = (Dali::BaseHandle *)jarg1;
65668   if (!argp1) {
65669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65670     return 0;
65671   }
65672   arg1 = *argp1;
65673   {
65674     try {
65675       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65676     } catch (std::out_of_range& e) {
65677       {
65678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65679       };
65680     } catch (std::exception& e) {
65681       {
65682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65683       };
65684     } catch (...) {
65685       {
65686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65687       };
65688     }
65689   }
65690   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65691   return jresult;
65692 }
65693
65694
65695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65696   int jresult ;
65697   int result;
65698
65699   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65700   jresult = (int)result;
65701   return jresult;
65702 }
65703
65704
65705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65706   int jresult ;
65707   int result;
65708
65709   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65710   jresult = (int)result;
65711   return jresult;
65712 }
65713
65714
65715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65716   int jresult ;
65717   int result;
65718
65719   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65720   jresult = (int)result;
65721   return jresult;
65722 }
65723
65724
65725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65726   int jresult ;
65727   int result;
65728
65729   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65730   jresult = (int)result;
65731   return jresult;
65732 }
65733
65734
65735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65736   int jresult ;
65737   int result;
65738
65739   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65740   jresult = (int)result;
65741   return jresult;
65742 }
65743
65744
65745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65746   int jresult ;
65747   int result;
65748
65749   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65750   jresult = (int)result;
65751   return jresult;
65752 }
65753
65754
65755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65756   void * jresult ;
65757   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65758
65759   {
65760     try {
65761       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
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 = (void *)result;
65777   return jresult;
65778 }
65779
65780
65781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65782   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65783
65784   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
65785   {
65786     try {
65787       delete arg1;
65788     } catch (std::out_of_range& e) {
65789       {
65790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65791       };
65792     } catch (std::exception& e) {
65793       {
65794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65795       };
65796     } catch (...) {
65797       {
65798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65799       };
65800     }
65801   }
65802 }
65803
65804
65805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
65806   int jresult ;
65807   int result;
65808
65809   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
65810   jresult = (int)result;
65811   return jresult;
65812 }
65813
65814
65815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
65816   int jresult ;
65817   int result;
65818
65819   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
65820   jresult = (int)result;
65821   return jresult;
65822 }
65823
65824
65825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
65826   int jresult ;
65827   int result;
65828
65829   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
65830   jresult = (int)result;
65831   return jresult;
65832 }
65833
65834
65835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
65836   void * jresult ;
65837   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
65838
65839   {
65840     try {
65841       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
65842     } catch (std::out_of_range& e) {
65843       {
65844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65845       };
65846     } catch (std::exception& e) {
65847       {
65848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65849       };
65850     } catch (...) {
65851       {
65852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65853       };
65854     }
65855   }
65856   jresult = (void *)result;
65857   return jresult;
65858 }
65859
65860
65861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
65862   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
65863
65864   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
65865   {
65866     try {
65867       delete arg1;
65868     } catch (std::out_of_range& e) {
65869       {
65870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65871       };
65872     } catch (std::exception& e) {
65873       {
65874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65875       };
65876     } catch (...) {
65877       {
65878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65879       };
65880     }
65881   }
65882 }
65883
65884
65885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
65886   void * jresult ;
65887   Dali::Toolkit::FlexContainer *result = 0 ;
65888
65889   {
65890     try {
65891       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
65892     } catch (std::out_of_range& e) {
65893       {
65894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65895       };
65896     } catch (std::exception& e) {
65897       {
65898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65899       };
65900     } catch (...) {
65901       {
65902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65903       };
65904     }
65905   }
65906   jresult = (void *)result;
65907   return jresult;
65908 }
65909
65910
65911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
65912   void * jresult ;
65913   Dali::Toolkit::FlexContainer *arg1 = 0 ;
65914   Dali::Toolkit::FlexContainer *result = 0 ;
65915
65916   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65917   if (!arg1) {
65918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65919     return 0;
65920   }
65921   {
65922     try {
65923       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
65924     } catch (std::out_of_range& e) {
65925       {
65926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65927       };
65928     } catch (std::exception& e) {
65929       {
65930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65931       };
65932     } catch (...) {
65933       {
65934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65935       };
65936     }
65937   }
65938   jresult = (void *)result;
65939   return jresult;
65940 }
65941
65942
65943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
65944   void * jresult ;
65945   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65946   Dali::Toolkit::FlexContainer *arg2 = 0 ;
65947   Dali::Toolkit::FlexContainer *result = 0 ;
65948
65949   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65950   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
65951   if (!arg2) {
65952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65953     return 0;
65954   }
65955   {
65956     try {
65957       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
65958     } catch (std::out_of_range& e) {
65959       {
65960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65961       };
65962     } catch (std::exception& e) {
65963       {
65964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65965       };
65966     } catch (...) {
65967       {
65968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65969       };
65970     }
65971   }
65972   jresult = (void *)result;
65973   return jresult;
65974 }
65975
65976
65977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
65978   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
65979
65980   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65981   {
65982     try {
65983       delete arg1;
65984     } catch (std::out_of_range& e) {
65985       {
65986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65987       };
65988     } catch (std::exception& e) {
65989       {
65990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65991       };
65992     } catch (...) {
65993       {
65994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65995       };
65996     }
65997   }
65998 }
65999
66000
66001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66002   void * jresult ;
66003   Dali::Toolkit::FlexContainer result;
66004
66005   {
66006     try {
66007       result = Dali::Toolkit::FlexContainer::New();
66008     } catch (std::out_of_range& e) {
66009       {
66010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66011       };
66012     } catch (std::exception& e) {
66013       {
66014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66015       };
66016     } catch (...) {
66017       {
66018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66019       };
66020     }
66021   }
66022   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66023   return jresult;
66024 }
66025
66026
66027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66028   void * jresult ;
66029   Dali::BaseHandle arg1 ;
66030   Dali::BaseHandle *argp1 ;
66031   Dali::Toolkit::FlexContainer result;
66032
66033   argp1 = (Dali::BaseHandle *)jarg1;
66034   if (!argp1) {
66035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66036     return 0;
66037   }
66038   arg1 = *argp1;
66039   {
66040     try {
66041       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66042     } catch (std::out_of_range& e) {
66043       {
66044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66045       };
66046     } catch (std::exception& e) {
66047       {
66048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66049       };
66050     } catch (...) {
66051       {
66052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66053       };
66054     }
66055   }
66056   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66057   return jresult;
66058 }
66059
66060
66061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
66062   int jresult ;
66063   int result;
66064
66065   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
66066   jresult = (int)result;
66067   return jresult;
66068 }
66069
66070
66071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66072   int jresult ;
66073   int result;
66074
66075   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66076   jresult = (int)result;
66077   return jresult;
66078 }
66079
66080
66081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66082   int jresult ;
66083   int result;
66084
66085   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66086   jresult = (int)result;
66087   return jresult;
66088 }
66089
66090
66091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66092   int jresult ;
66093   int result;
66094
66095   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66096   jresult = (int)result;
66097   return jresult;
66098 }
66099
66100
66101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66102   void * jresult ;
66103   Dali::Toolkit::ImageView::Property *result = 0 ;
66104
66105   {
66106     try {
66107       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
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_delete_ImageView_Property(void * jarg1) {
66128   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66129
66130   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66131   {
66132     try {
66133       delete arg1;
66134     } catch (std::out_of_range& e) {
66135       {
66136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66137       };
66138     } catch (std::exception& e) {
66139       {
66140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66141       };
66142     } catch (...) {
66143       {
66144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66145       };
66146     }
66147   }
66148 }
66149
66150
66151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66152   void * jresult ;
66153   Dali::Toolkit::ImageView *result = 0 ;
66154
66155   {
66156     try {
66157       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66158     } catch (std::out_of_range& e) {
66159       {
66160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66161       };
66162     } catch (std::exception& e) {
66163       {
66164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66165       };
66166     } catch (...) {
66167       {
66168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66169       };
66170     }
66171   }
66172   jresult = (void *)result;
66173   return jresult;
66174 }
66175
66176
66177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66178   void * jresult ;
66179   Dali::Toolkit::ImageView result;
66180
66181   {
66182     try {
66183       result = Dali::Toolkit::ImageView::New();
66184     } catch (std::out_of_range& e) {
66185       {
66186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66187       };
66188     } catch (std::exception& e) {
66189       {
66190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66191       };
66192     } catch (...) {
66193       {
66194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66195       };
66196     }
66197   }
66198   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66199   return jresult;
66200 }
66201
66202
66203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
66204   void * jresult ;
66205   Dali::Image arg1 ;
66206   Dali::Image *argp1 ;
66207   Dali::Toolkit::ImageView result;
66208
66209   argp1 = (Dali::Image *)jarg1;
66210   if (!argp1) {
66211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66212     return 0;
66213   }
66214   arg1 = *argp1;
66215   {
66216     try {
66217       result = Dali::Toolkit::ImageView::New(arg1);
66218     } catch (std::out_of_range& e) {
66219       {
66220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66221       };
66222     } catch (std::exception& e) {
66223       {
66224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66225       };
66226     } catch (...) {
66227       {
66228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66229       };
66230     }
66231   }
66232   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66233   return jresult;
66234 }
66235
66236
66237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66238   void * jresult ;
66239   std::string *arg1 = 0 ;
66240   Dali::Toolkit::ImageView result;
66241
66242   if (!jarg1) {
66243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66244     return 0;
66245   }
66246   std::string arg1_str(jarg1);
66247   arg1 = &arg1_str;
66248   {
66249     try {
66250       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66251     } catch (std::out_of_range& e) {
66252       {
66253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66254       };
66255     } catch (std::exception& e) {
66256       {
66257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66258       };
66259     } catch (...) {
66260       {
66261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66262       };
66263     }
66264   }
66265   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66266
66267   //argout typemap for const std::string&
66268
66269   return jresult;
66270 }
66271
66272
66273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66274   void * jresult ;
66275   std::string *arg1 = 0 ;
66276   Dali::ImageDimensions arg2 ;
66277   Dali::ImageDimensions *argp2 ;
66278   Dali::Toolkit::ImageView result;
66279
66280   if (!jarg1) {
66281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66282     return 0;
66283   }
66284   std::string arg1_str(jarg1);
66285   arg1 = &arg1_str;
66286   argp2 = (Dali::ImageDimensions *)jarg2;
66287   if (!argp2) {
66288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66289     return 0;
66290   }
66291   arg2 = *argp2;
66292   {
66293     try {
66294       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66295     } catch (std::out_of_range& e) {
66296       {
66297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66298       };
66299     } catch (std::exception& e) {
66300       {
66301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66302       };
66303     } catch (...) {
66304       {
66305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66306       };
66307     }
66308   }
66309   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66310
66311   //argout typemap for const std::string&
66312
66313   return jresult;
66314 }
66315
66316
66317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66318   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66319
66320   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66321   {
66322     try {
66323       delete arg1;
66324     } catch (std::out_of_range& e) {
66325       {
66326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66327       };
66328     } catch (std::exception& e) {
66329       {
66330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66331       };
66332     } catch (...) {
66333       {
66334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66335       };
66336     }
66337   }
66338 }
66339
66340
66341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66342   void * jresult ;
66343   Dali::Toolkit::ImageView *arg1 = 0 ;
66344   Dali::Toolkit::ImageView *result = 0 ;
66345
66346   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66347   if (!arg1) {
66348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66349     return 0;
66350   }
66351   {
66352     try {
66353       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66354     } catch (std::out_of_range& e) {
66355       {
66356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66357       };
66358     } catch (std::exception& e) {
66359       {
66360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66361       };
66362     } catch (...) {
66363       {
66364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66365       };
66366     }
66367   }
66368   jresult = (void *)result;
66369   return jresult;
66370 }
66371
66372
66373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66374   void * jresult ;
66375   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66376   Dali::Toolkit::ImageView *arg2 = 0 ;
66377   Dali::Toolkit::ImageView *result = 0 ;
66378
66379   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66380   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66381   if (!arg2) {
66382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66383     return 0;
66384   }
66385   {
66386     try {
66387       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66388     } catch (std::out_of_range& e) {
66389       {
66390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66391       };
66392     } catch (std::exception& e) {
66393       {
66394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66395       };
66396     } catch (...) {
66397       {
66398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66399       };
66400     }
66401   }
66402   jresult = (void *)result;
66403   return jresult;
66404 }
66405
66406
66407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66408   void * jresult ;
66409   Dali::BaseHandle arg1 ;
66410   Dali::BaseHandle *argp1 ;
66411   Dali::Toolkit::ImageView result;
66412
66413   argp1 = (Dali::BaseHandle *)jarg1;
66414   if (!argp1) {
66415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66416     return 0;
66417   }
66418   arg1 = *argp1;
66419   {
66420     try {
66421       result = Dali::Toolkit::ImageView::DownCast(arg1);
66422     } catch (std::out_of_range& e) {
66423       {
66424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66425       };
66426     } catch (std::exception& e) {
66427       {
66428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66429       };
66430     } catch (...) {
66431       {
66432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66433       };
66434     }
66435   }
66436   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66437   return jresult;
66438 }
66439
66440
66441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
66442   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66443   Dali::Image arg2 ;
66444   Dali::Image *argp2 ;
66445
66446   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66447   argp2 = (Dali::Image *)jarg2;
66448   if (!argp2) {
66449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
66450     return ;
66451   }
66452   arg2 = *argp2;
66453   {
66454     try {
66455       (arg1)->SetImage(arg2);
66456     } catch (std::out_of_range& e) {
66457       {
66458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66459       };
66460     } catch (std::exception& e) {
66461       {
66462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66463       };
66464     } catch (...) {
66465       {
66466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66467       };
66468     }
66469   }
66470 }
66471
66472
66473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66474   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66475   std::string *arg2 = 0 ;
66476
66477   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66478   if (!jarg2) {
66479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66480     return ;
66481   }
66482   std::string arg2_str(jarg2);
66483   arg2 = &arg2_str;
66484   {
66485     try {
66486       (arg1)->SetImage((std::string const &)*arg2);
66487     } catch (std::out_of_range& e) {
66488       {
66489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66490       };
66491     } catch (std::exception& e) {
66492       {
66493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66494       };
66495     } catch (...) {
66496       {
66497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66498       };
66499     }
66500   }
66501
66502   //argout typemap for const std::string&
66503
66504 }
66505
66506
66507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66508   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66509   std::string *arg2 = 0 ;
66510   Dali::ImageDimensions arg3 ;
66511   Dali::ImageDimensions *argp3 ;
66512
66513   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66514   if (!jarg2) {
66515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66516     return ;
66517   }
66518   std::string arg2_str(jarg2);
66519   arg2 = &arg2_str;
66520   argp3 = (Dali::ImageDimensions *)jarg3;
66521   if (!argp3) {
66522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66523     return ;
66524   }
66525   arg3 = *argp3;
66526   {
66527     try {
66528       (arg1)->SetImage((std::string const &)*arg2,arg3);
66529     } catch (std::out_of_range& e) {
66530       {
66531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66532       };
66533     } catch (std::exception& e) {
66534       {
66535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66536       };
66537     } catch (...) {
66538       {
66539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66540       };
66541     }
66542   }
66543
66544   //argout typemap for const std::string&
66545
66546 }
66547
66548
66549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
66550   void * jresult ;
66551   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66552   Dali::Image result;
66553
66554   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66555   {
66556     try {
66557       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
66558     } catch (std::out_of_range& e) {
66559       {
66560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66561       };
66562     } catch (std::exception& e) {
66563       {
66564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66565       };
66566     } catch (...) {
66567       {
66568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66569       };
66570     }
66571   }
66572   jresult = new Dali::Image((const Dali::Image &)result);
66573   return jresult;
66574 }
66575
66576
66577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66578   int jresult ;
66579   int result;
66580
66581   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66582   jresult = (int)result;
66583   return jresult;
66584 }
66585
66586
66587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66588   int jresult ;
66589   int result;
66590
66591   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66592   jresult = (int)result;
66593   return jresult;
66594 }
66595
66596
66597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66598   int jresult ;
66599   int result;
66600
66601   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66602   jresult = (int)result;
66603   return jresult;
66604 }
66605
66606
66607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66608   int jresult ;
66609   int result;
66610
66611   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66612   jresult = (int)result;
66613   return jresult;
66614 }
66615
66616
66617 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66618   int jresult ;
66619   int result;
66620
66621   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66622   jresult = (int)result;
66623   return jresult;
66624 }
66625
66626
66627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66628   int jresult ;
66629   int result;
66630
66631   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66632   jresult = (int)result;
66633   return jresult;
66634 }
66635
66636
66637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66638   int jresult ;
66639   int result;
66640
66641   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66642   jresult = (int)result;
66643   return jresult;
66644 }
66645
66646
66647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66648   int jresult ;
66649   int result;
66650
66651   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66652   jresult = (int)result;
66653   return jresult;
66654 }
66655
66656
66657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66658   void * jresult ;
66659   Dali::Toolkit::Model3dView::Property *result = 0 ;
66660
66661   {
66662     try {
66663       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66664     } catch (std::out_of_range& e) {
66665       {
66666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66667       };
66668     } catch (std::exception& e) {
66669       {
66670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66671       };
66672     } catch (...) {
66673       {
66674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66675       };
66676     }
66677   }
66678   jresult = (void *)result;
66679   return jresult;
66680 }
66681
66682
66683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66684   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66685
66686   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66687   {
66688     try {
66689       delete arg1;
66690     } catch (std::out_of_range& e) {
66691       {
66692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66693       };
66694     } catch (std::exception& e) {
66695       {
66696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66697       };
66698     } catch (...) {
66699       {
66700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66701       };
66702     }
66703   }
66704 }
66705
66706
66707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66708   void * jresult ;
66709   Dali::Toolkit::Model3dView result;
66710
66711   {
66712     try {
66713       result = Dali::Toolkit::Model3dView::New();
66714     } catch (std::out_of_range& e) {
66715       {
66716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66717       };
66718     } catch (std::exception& e) {
66719       {
66720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66721       };
66722     } catch (...) {
66723       {
66724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66725       };
66726     }
66727   }
66728   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66729   return jresult;
66730 }
66731
66732
66733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66734   void * jresult ;
66735   std::string *arg1 = 0 ;
66736   std::string *arg2 = 0 ;
66737   std::string *arg3 = 0 ;
66738   Dali::Toolkit::Model3dView result;
66739
66740   if (!jarg1) {
66741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66742     return 0;
66743   }
66744   std::string arg1_str(jarg1);
66745   arg1 = &arg1_str;
66746   if (!jarg2) {
66747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66748     return 0;
66749   }
66750   std::string arg2_str(jarg2);
66751   arg2 = &arg2_str;
66752   if (!jarg3) {
66753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66754     return 0;
66755   }
66756   std::string arg3_str(jarg3);
66757   arg3 = &arg3_str;
66758   {
66759     try {
66760       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66761     } catch (std::out_of_range& e) {
66762       {
66763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66764       };
66765     } catch (std::exception& e) {
66766       {
66767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66768       };
66769     } catch (...) {
66770       {
66771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66772       };
66773     }
66774   }
66775   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66776
66777   //argout typemap for const std::string&
66778
66779
66780   //argout typemap for const std::string&
66781
66782
66783   //argout typemap for const std::string&
66784
66785   return jresult;
66786 }
66787
66788
66789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
66790   void * jresult ;
66791   Dali::Toolkit::Model3dView *result = 0 ;
66792
66793   {
66794     try {
66795       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
66796     } catch (std::out_of_range& e) {
66797       {
66798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66799       };
66800     } catch (std::exception& e) {
66801       {
66802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66803       };
66804     } catch (...) {
66805       {
66806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66807       };
66808     }
66809   }
66810   jresult = (void *)result;
66811   return jresult;
66812 }
66813
66814
66815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
66816   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66817
66818   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66819   {
66820     try {
66821       delete arg1;
66822     } catch (std::out_of_range& e) {
66823       {
66824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66825       };
66826     } catch (std::exception& e) {
66827       {
66828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66829       };
66830     } catch (...) {
66831       {
66832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66833       };
66834     }
66835   }
66836 }
66837
66838
66839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
66840   void * jresult ;
66841   Dali::Toolkit::Model3dView *arg1 = 0 ;
66842   Dali::Toolkit::Model3dView *result = 0 ;
66843
66844   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66845   if (!arg1) {
66846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66847     return 0;
66848   }
66849   {
66850     try {
66851       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
66852     } catch (std::out_of_range& e) {
66853       {
66854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66855       };
66856     } catch (std::exception& e) {
66857       {
66858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66859       };
66860     } catch (...) {
66861       {
66862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66863       };
66864     }
66865   }
66866   jresult = (void *)result;
66867   return jresult;
66868 }
66869
66870
66871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
66872   void * jresult ;
66873   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66874   Dali::Toolkit::Model3dView *arg2 = 0 ;
66875   Dali::Toolkit::Model3dView *result = 0 ;
66876
66877   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66878   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
66879   if (!arg2) {
66880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66881     return 0;
66882   }
66883   {
66884     try {
66885       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
66886     } catch (std::out_of_range& e) {
66887       {
66888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66889       };
66890     } catch (std::exception& e) {
66891       {
66892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66893       };
66894     } catch (...) {
66895       {
66896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66897       };
66898     }
66899   }
66900   jresult = (void *)result;
66901   return jresult;
66902 }
66903
66904
66905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
66906   void * jresult ;
66907   Dali::BaseHandle arg1 ;
66908   Dali::BaseHandle *argp1 ;
66909   Dali::Toolkit::Model3dView result;
66910
66911   argp1 = (Dali::BaseHandle *)jarg1;
66912   if (!argp1) {
66913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66914     return 0;
66915   }
66916   arg1 = *argp1;
66917   {
66918     try {
66919       result = Dali::Toolkit::Model3dView::DownCast(arg1);
66920     } catch (std::out_of_range& e) {
66921       {
66922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66923       };
66924     } catch (std::exception& e) {
66925       {
66926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66927       };
66928     } catch (...) {
66929       {
66930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66931       };
66932     }
66933   }
66934   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66935   return jresult;
66936 }
66937
66938
66939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
66940   int jresult ;
66941   int result;
66942
66943   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
66944   jresult = (int)result;
66945   return jresult;
66946 }
66947
66948
66949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
66950   int jresult ;
66951   int result;
66952
66953   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
66954   jresult = (int)result;
66955   return jresult;
66956 }
66957
66958
66959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
66960   int jresult ;
66961   int result;
66962
66963   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
66964   jresult = (int)result;
66965   return jresult;
66966 }
66967
66968
66969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
66970   int jresult ;
66971   int result;
66972
66973   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
66974   jresult = (int)result;
66975   return jresult;
66976 }
66977
66978
66979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
66980   int jresult ;
66981   int result;
66982
66983   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
66984   jresult = (int)result;
66985   return jresult;
66986 }
66987
66988
66989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
66990   int jresult ;
66991   int result;
66992
66993   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
66994   jresult = (int)result;
66995   return jresult;
66996 }
66997
66998
66999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67000   int jresult ;
67001   int result;
67002
67003   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67004   jresult = (int)result;
67005   return jresult;
67006 }
67007
67008
67009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67010   int jresult ;
67011   int result;
67012
67013   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67014   jresult = (int)result;
67015   return jresult;
67016 }
67017
67018
67019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67020   int jresult ;
67021   int result;
67022
67023   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67024   jresult = (int)result;
67025   return jresult;
67026 }
67027
67028
67029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67030   void * jresult ;
67031   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67032
67033   {
67034     try {
67035       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67036     } catch (std::out_of_range& e) {
67037       {
67038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67039       };
67040     } catch (std::exception& e) {
67041       {
67042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67043       };
67044     } catch (...) {
67045       {
67046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67047       };
67048     }
67049   }
67050   jresult = (void *)result;
67051   return jresult;
67052 }
67053
67054
67055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67056   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67057
67058   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67059   {
67060     try {
67061       delete arg1;
67062     } catch (std::out_of_range& e) {
67063       {
67064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67065       };
67066     } catch (std::exception& e) {
67067       {
67068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67069       };
67070     } catch (...) {
67071       {
67072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67073       };
67074     }
67075   }
67076 }
67077
67078
67079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67080   void * jresult ;
67081   Dali::Toolkit::ScrollBar *result = 0 ;
67082
67083   {
67084     try {
67085       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67086     } catch (std::out_of_range& e) {
67087       {
67088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67089       };
67090     } catch (std::exception& e) {
67091       {
67092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67093       };
67094     } catch (...) {
67095       {
67096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67097       };
67098     }
67099   }
67100   jresult = (void *)result;
67101   return jresult;
67102 }
67103
67104
67105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67106   void * jresult ;
67107   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67108   Dali::Toolkit::ScrollBar *result = 0 ;
67109
67110   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67111   if (!arg1) {
67112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67113     return 0;
67114   }
67115   {
67116     try {
67117       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
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 = (void *)result;
67133   return jresult;
67134 }
67135
67136
67137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67138   void * jresult ;
67139   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67140   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67141   Dali::Toolkit::ScrollBar *result = 0 ;
67142
67143   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67144   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67145   if (!arg2) {
67146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67147     return 0;
67148   }
67149   {
67150     try {
67151       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67152     } catch (std::out_of_range& e) {
67153       {
67154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67155       };
67156     } catch (std::exception& e) {
67157       {
67158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67159       };
67160     } catch (...) {
67161       {
67162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67163       };
67164     }
67165   }
67166   jresult = (void *)result;
67167   return jresult;
67168 }
67169
67170
67171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67172   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67173
67174   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67175   {
67176     try {
67177       delete arg1;
67178     } catch (std::out_of_range& e) {
67179       {
67180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67181       };
67182     } catch (std::exception& e) {
67183       {
67184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67185       };
67186     } catch (...) {
67187       {
67188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67189       };
67190     }
67191   }
67192 }
67193
67194
67195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67196   void * jresult ;
67197   Dali::Toolkit::ScrollBar::Direction arg1 ;
67198   Dali::Toolkit::ScrollBar result;
67199
67200   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67201   {
67202     try {
67203       result = Dali::Toolkit::ScrollBar::New(arg1);
67204     } catch (std::out_of_range& e) {
67205       {
67206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67207       };
67208     } catch (std::exception& e) {
67209       {
67210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67211       };
67212     } catch (...) {
67213       {
67214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67215       };
67216     }
67217   }
67218   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67219   return jresult;
67220 }
67221
67222
67223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67224   void * jresult ;
67225   Dali::Toolkit::ScrollBar result;
67226
67227   {
67228     try {
67229       result = Dali::Toolkit::ScrollBar::New();
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 = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67245   return jresult;
67246 }
67247
67248
67249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67250   void * jresult ;
67251   Dali::BaseHandle arg1 ;
67252   Dali::BaseHandle *argp1 ;
67253   Dali::Toolkit::ScrollBar result;
67254
67255   argp1 = (Dali::BaseHandle *)jarg1;
67256   if (!argp1) {
67257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67258     return 0;
67259   }
67260   arg1 = *argp1;
67261   {
67262     try {
67263       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67264     } catch (std::out_of_range& e) {
67265       {
67266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67267       };
67268     } catch (std::exception& e) {
67269       {
67270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67271       };
67272     } catch (...) {
67273       {
67274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67275       };
67276     }
67277   }
67278   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67279   return jresult;
67280 }
67281
67282
67283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67284   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67285   Dali::Handle arg2 ;
67286   Dali::Property::Index arg3 ;
67287   Dali::Property::Index arg4 ;
67288   Dali::Property::Index arg5 ;
67289   Dali::Property::Index arg6 ;
67290   Dali::Handle *argp2 ;
67291
67292   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67293   argp2 = (Dali::Handle *)jarg2;
67294   if (!argp2) {
67295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67296     return ;
67297   }
67298   arg2 = *argp2;
67299   arg3 = (Dali::Property::Index)jarg3;
67300   arg4 = (Dali::Property::Index)jarg4;
67301   arg5 = (Dali::Property::Index)jarg5;
67302   arg6 = (Dali::Property::Index)jarg6;
67303   {
67304     try {
67305       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67306     } catch (std::out_of_range& e) {
67307       {
67308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67309       };
67310     } catch (std::exception& e) {
67311       {
67312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67313       };
67314     } catch (...) {
67315       {
67316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67317       };
67318     }
67319   }
67320 }
67321
67322
67323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67324   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67325   Dali::Actor arg2 ;
67326   Dali::Actor *argp2 ;
67327
67328   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67329   argp2 = (Dali::Actor *)jarg2;
67330   if (!argp2) {
67331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67332     return ;
67333   }
67334   arg2 = *argp2;
67335   {
67336     try {
67337       (arg1)->SetScrollIndicator(arg2);
67338     } catch (std::out_of_range& e) {
67339       {
67340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67341       };
67342     } catch (std::exception& e) {
67343       {
67344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67345       };
67346     } catch (...) {
67347       {
67348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67349       };
67350     }
67351   }
67352 }
67353
67354
67355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67356   void * jresult ;
67357   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67358   Dali::Actor result;
67359
67360   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67361   {
67362     try {
67363       result = (arg1)->GetScrollIndicator();
67364     } catch (std::out_of_range& e) {
67365       {
67366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67367       };
67368     } catch (std::exception& e) {
67369       {
67370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67371       };
67372     } catch (...) {
67373       {
67374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67375       };
67376     }
67377   }
67378   jresult = new Dali::Actor((const Dali::Actor &)result);
67379   return jresult;
67380 }
67381
67382
67383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67384   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67385   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67386
67387   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67388   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67389   if (!arg2) {
67390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67391     return ;
67392   }
67393   {
67394     try {
67395       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67396     } catch (std::out_of_range& e) {
67397       {
67398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67399       };
67400     } catch (std::exception& e) {
67401       {
67402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67403       };
67404     } catch (...) {
67405       {
67406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67407       };
67408     }
67409   }
67410 }
67411
67412
67413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67414   void * jresult ;
67415   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67416   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > result;
67417
67418   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67419   {
67420     try {
67421       result = ((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals();
67422     } catch (std::out_of_range& e) {
67423       {
67424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67425       };
67426     } catch (std::exception& e) {
67427       {
67428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67429       };
67430     } catch (...) {
67431       {
67432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67433       };
67434     }
67435   }
67436   jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)result);
67437   return jresult;
67438 }
67439
67440
67441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67442   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67443   Dali::Toolkit::ScrollBar::Direction arg2 ;
67444
67445   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67446   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67447   {
67448     try {
67449       (arg1)->SetScrollDirection(arg2);
67450     } catch (std::out_of_range& e) {
67451       {
67452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67453       };
67454     } catch (std::exception& e) {
67455       {
67456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67457       };
67458     } catch (...) {
67459       {
67460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67461       };
67462     }
67463   }
67464 }
67465
67466
67467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67468   int jresult ;
67469   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67470   Dali::Toolkit::ScrollBar::Direction result;
67471
67472   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67473   {
67474     try {
67475       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67476     } catch (std::out_of_range& e) {
67477       {
67478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67479       };
67480     } catch (std::exception& e) {
67481       {
67482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67483       };
67484     } catch (...) {
67485       {
67486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67487       };
67488     }
67489   }
67490   jresult = (int)result;
67491   return jresult;
67492 }
67493
67494
67495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67496   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67497   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67498
67499   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67500   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67501   {
67502     try {
67503       (arg1)->SetIndicatorHeightPolicy(arg2);
67504     } catch (std::out_of_range& e) {
67505       {
67506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67507       };
67508     } catch (std::exception& e) {
67509       {
67510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67511       };
67512     } catch (...) {
67513       {
67514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67515       };
67516     }
67517   }
67518 }
67519
67520
67521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67522   int jresult ;
67523   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67524   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67525
67526   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67527   {
67528     try {
67529       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67530     } catch (std::out_of_range& e) {
67531       {
67532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67533       };
67534     } catch (std::exception& e) {
67535       {
67536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67537       };
67538     } catch (...) {
67539       {
67540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67541       };
67542     }
67543   }
67544   jresult = (int)result;
67545   return jresult;
67546 }
67547
67548
67549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67550   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67551   float arg2 ;
67552
67553   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67554   arg2 = (float)jarg2;
67555   {
67556     try {
67557       (arg1)->SetIndicatorFixedHeight(arg2);
67558     } catch (std::out_of_range& e) {
67559       {
67560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67561       };
67562     } catch (std::exception& e) {
67563       {
67564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67565       };
67566     } catch (...) {
67567       {
67568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67569       };
67570     }
67571   }
67572 }
67573
67574
67575 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67576   float jresult ;
67577   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67578   float result;
67579
67580   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67581   {
67582     try {
67583       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67584     } catch (std::out_of_range& e) {
67585       {
67586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67587       };
67588     } catch (std::exception& e) {
67589       {
67590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67591       };
67592     } catch (...) {
67593       {
67594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67595       };
67596     }
67597   }
67598   jresult = result;
67599   return jresult;
67600 }
67601
67602
67603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67604   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67605   float arg2 ;
67606
67607   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67608   arg2 = (float)jarg2;
67609   {
67610     try {
67611       (arg1)->SetIndicatorShowDuration(arg2);
67612     } catch (std::out_of_range& e) {
67613       {
67614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67615       };
67616     } catch (std::exception& e) {
67617       {
67618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67619       };
67620     } catch (...) {
67621       {
67622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67623       };
67624     }
67625   }
67626 }
67627
67628
67629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67630   float jresult ;
67631   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67632   float result;
67633
67634   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67635   {
67636     try {
67637       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67638     } catch (std::out_of_range& e) {
67639       {
67640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67641       };
67642     } catch (std::exception& e) {
67643       {
67644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67645       };
67646     } catch (...) {
67647       {
67648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67649       };
67650     }
67651   }
67652   jresult = result;
67653   return jresult;
67654 }
67655
67656
67657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67658   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67659   float arg2 ;
67660
67661   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67662   arg2 = (float)jarg2;
67663   {
67664     try {
67665       (arg1)->SetIndicatorHideDuration(arg2);
67666     } catch (std::out_of_range& e) {
67667       {
67668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67669       };
67670     } catch (std::exception& e) {
67671       {
67672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67673       };
67674     } catch (...) {
67675       {
67676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67677       };
67678     }
67679   }
67680 }
67681
67682
67683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67684   float jresult ;
67685   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67686   float result;
67687
67688   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67689   {
67690     try {
67691       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67692     } catch (std::out_of_range& e) {
67693       {
67694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67695       };
67696     } catch (std::exception& e) {
67697       {
67698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67699       };
67700     } catch (...) {
67701       {
67702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67703       };
67704     }
67705   }
67706   jresult = result;
67707   return jresult;
67708 }
67709
67710
67711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
67712   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67713
67714   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67715   {
67716     try {
67717       (arg1)->ShowIndicator();
67718     } catch (std::out_of_range& e) {
67719       {
67720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67721       };
67722     } catch (std::exception& e) {
67723       {
67724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67725       };
67726     } catch (...) {
67727       {
67728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67729       };
67730     }
67731   }
67732 }
67733
67734
67735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
67736   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67737
67738   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67739   {
67740     try {
67741       (arg1)->HideIndicator();
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_ScrollBar_PanFinishedSignal(void * jarg1) {
67760   void * jresult ;
67761   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67762   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
67763
67764   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67765   {
67766     try {
67767       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
67768     } catch (std::out_of_range& e) {
67769       {
67770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67771       };
67772     } catch (std::exception& e) {
67773       {
67774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67775       };
67776     } catch (...) {
67777       {
67778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67779       };
67780     }
67781   }
67782   jresult = (void *)result;
67783   return jresult;
67784 }
67785
67786
67787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
67788   void * jresult ;
67789   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67790   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
67791
67792   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67793   {
67794     try {
67795       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
67796     } catch (std::out_of_range& e) {
67797       {
67798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67799       };
67800     } catch (std::exception& e) {
67801       {
67802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67803       };
67804     } catch (...) {
67805       {
67806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67807       };
67808     }
67809   }
67810   jresult = (void *)result;
67811   return jresult;
67812 }
67813
67814
67815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
67816   int jresult ;
67817   int result;
67818
67819   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
67820   jresult = (int)result;
67821   return jresult;
67822 }
67823
67824
67825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
67826   int jresult ;
67827   int result;
67828
67829   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
67830   jresult = (int)result;
67831   return jresult;
67832 }
67833
67834
67835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
67836   int jresult ;
67837   int result;
67838
67839   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
67840   jresult = (int)result;
67841   return jresult;
67842 }
67843
67844
67845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
67846   int jresult ;
67847   int result;
67848
67849   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
67850   jresult = (int)result;
67851   return jresult;
67852 }
67853
67854
67855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
67856   int jresult ;
67857   int result;
67858
67859   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
67860   jresult = (int)result;
67861   return jresult;
67862 }
67863
67864
67865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
67866   int jresult ;
67867   int result;
67868
67869   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
67870   jresult = (int)result;
67871   return jresult;
67872 }
67873
67874
67875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
67876   int jresult ;
67877   int result;
67878
67879   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
67880   jresult = (int)result;
67881   return jresult;
67882 }
67883
67884
67885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
67886   int jresult ;
67887   int result;
67888
67889   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
67890   jresult = (int)result;
67891   return jresult;
67892 }
67893
67894
67895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
67896   int jresult ;
67897   int result;
67898
67899   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
67900   jresult = (int)result;
67901   return jresult;
67902 }
67903
67904
67905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
67906   int jresult ;
67907   int result;
67908
67909   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
67910   jresult = (int)result;
67911   return jresult;
67912 }
67913
67914
67915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
67916   int jresult ;
67917   int result;
67918
67919   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
67920   jresult = (int)result;
67921   return jresult;
67922 }
67923
67924
67925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
67926   int jresult ;
67927   int result;
67928
67929   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
67930   jresult = (int)result;
67931   return jresult;
67932 }
67933
67934
67935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
67936   int jresult ;
67937   int result;
67938
67939   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
67940   jresult = (int)result;
67941   return jresult;
67942 }
67943
67944
67945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
67946   int jresult ;
67947   int result;
67948
67949   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
67950   jresult = (int)result;
67951   return jresult;
67952 }
67953
67954
67955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
67956   void * jresult ;
67957   Dali::Toolkit::Scrollable::Property *result = 0 ;
67958
67959   {
67960     try {
67961       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
67962     } catch (std::out_of_range& e) {
67963       {
67964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67965       };
67966     } catch (std::exception& e) {
67967       {
67968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67969       };
67970     } catch (...) {
67971       {
67972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67973       };
67974     }
67975   }
67976   jresult = (void *)result;
67977   return jresult;
67978 }
67979
67980
67981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
67982   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
67983
67984   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
67985   {
67986     try {
67987       delete arg1;
67988     } catch (std::out_of_range& e) {
67989       {
67990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67991       };
67992     } catch (std::exception& e) {
67993       {
67994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67995       };
67996     } catch (...) {
67997       {
67998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67999       };
68000     }
68001   }
68002 }
68003
68004
68005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68006   void * jresult ;
68007   Dali::Toolkit::Scrollable *result = 0 ;
68008
68009   {
68010     try {
68011       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68012     } catch (std::out_of_range& e) {
68013       {
68014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68015       };
68016     } catch (std::exception& e) {
68017       {
68018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68019       };
68020     } catch (...) {
68021       {
68022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68023       };
68024     }
68025   }
68026   jresult = (void *)result;
68027   return jresult;
68028 }
68029
68030
68031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68032   void * jresult ;
68033   Dali::Toolkit::Scrollable *arg1 = 0 ;
68034   Dali::Toolkit::Scrollable *result = 0 ;
68035
68036   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68037   if (!arg1) {
68038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68039     return 0;
68040   }
68041   {
68042     try {
68043       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68044     } catch (std::out_of_range& e) {
68045       {
68046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68047       };
68048     } catch (std::exception& e) {
68049       {
68050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68051       };
68052     } catch (...) {
68053       {
68054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68055       };
68056     }
68057   }
68058   jresult = (void *)result;
68059   return jresult;
68060 }
68061
68062
68063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68064   void * jresult ;
68065   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68066   Dali::Toolkit::Scrollable *arg2 = 0 ;
68067   Dali::Toolkit::Scrollable *result = 0 ;
68068
68069   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68070   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68071   if (!arg2) {
68072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68073     return 0;
68074   }
68075   {
68076     try {
68077       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68078     } catch (std::out_of_range& e) {
68079       {
68080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68081       };
68082     } catch (std::exception& e) {
68083       {
68084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68085       };
68086     } catch (...) {
68087       {
68088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68089       };
68090     }
68091   }
68092   jresult = (void *)result;
68093   return jresult;
68094 }
68095
68096
68097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68098   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68099
68100   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68101   {
68102     try {
68103       delete arg1;
68104     } catch (std::out_of_range& e) {
68105       {
68106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68107       };
68108     } catch (std::exception& e) {
68109       {
68110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68111       };
68112     } catch (...) {
68113       {
68114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68115       };
68116     }
68117   }
68118 }
68119
68120
68121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68122   void * jresult ;
68123   Dali::BaseHandle arg1 ;
68124   Dali::BaseHandle *argp1 ;
68125   Dali::Toolkit::Scrollable result;
68126
68127   argp1 = (Dali::BaseHandle *)jarg1;
68128   if (!argp1) {
68129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68130     return 0;
68131   }
68132   arg1 = *argp1;
68133   {
68134     try {
68135       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68136     } catch (std::out_of_range& e) {
68137       {
68138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68139       };
68140     } catch (std::exception& e) {
68141       {
68142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68143       };
68144     } catch (...) {
68145       {
68146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68147       };
68148     }
68149   }
68150   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68151   return jresult;
68152 }
68153
68154
68155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68156   unsigned int jresult ;
68157   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68158   bool result;
68159
68160   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68161   {
68162     try {
68163       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68164     } catch (std::out_of_range& e) {
68165       {
68166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68167       };
68168     } catch (std::exception& e) {
68169       {
68170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68171       };
68172     } catch (...) {
68173       {
68174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68175       };
68176     }
68177   }
68178   jresult = result;
68179   return jresult;
68180 }
68181
68182
68183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68184   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68185   bool arg2 ;
68186
68187   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68188   arg2 = jarg2 ? true : false;
68189   {
68190     try {
68191       (arg1)->SetOvershootEnabled(arg2);
68192     } catch (std::out_of_range& e) {
68193       {
68194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68195       };
68196     } catch (std::exception& e) {
68197       {
68198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68199       };
68200     } catch (...) {
68201       {
68202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68203       };
68204     }
68205   }
68206 }
68207
68208
68209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68210   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68211   Dali::Vector4 *arg2 = 0 ;
68212
68213   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68214   arg2 = (Dali::Vector4 *)jarg2;
68215   if (!arg2) {
68216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68217     return ;
68218   }
68219   {
68220     try {
68221       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68222     } catch (std::out_of_range& e) {
68223       {
68224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68225       };
68226     } catch (std::exception& e) {
68227       {
68228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68229       };
68230     } catch (...) {
68231       {
68232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68233       };
68234     }
68235   }
68236 }
68237
68238
68239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68240   void * jresult ;
68241   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68242   Dali::Vector4 result;
68243
68244   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68245   {
68246     try {
68247       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68248     } catch (std::out_of_range& e) {
68249       {
68250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68251       };
68252     } catch (std::exception& e) {
68253       {
68254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68255       };
68256     } catch (...) {
68257       {
68258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68259       };
68260     }
68261   }
68262   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68263   return jresult;
68264 }
68265
68266
68267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68268   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68269   float arg2 ;
68270
68271   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68272   arg2 = (float)jarg2;
68273   {
68274     try {
68275       (arg1)->SetOvershootAnimationSpeed(arg2);
68276     } catch (std::out_of_range& e) {
68277       {
68278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68279       };
68280     } catch (std::exception& e) {
68281       {
68282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68283       };
68284     } catch (...) {
68285       {
68286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68287       };
68288     }
68289   }
68290 }
68291
68292
68293 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68294   float jresult ;
68295   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68296   float result;
68297
68298   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68299   {
68300     try {
68301       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68302     } catch (std::out_of_range& e) {
68303       {
68304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68305       };
68306     } catch (std::exception& e) {
68307       {
68308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68309       };
68310     } catch (...) {
68311       {
68312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68313       };
68314     }
68315   }
68316   jresult = result;
68317   return jresult;
68318 }
68319
68320
68321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68322   void * jresult ;
68323   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68324   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68325
68326   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68327   {
68328     try {
68329       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68330     } catch (std::out_of_range& e) {
68331       {
68332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68333       };
68334     } catch (std::exception& e) {
68335       {
68336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68337       };
68338     } catch (...) {
68339       {
68340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68341       };
68342     }
68343   }
68344   jresult = (void *)result;
68345   return jresult;
68346 }
68347
68348
68349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68350   void * jresult ;
68351   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68352   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68353
68354   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68355   {
68356     try {
68357       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68358     } catch (std::out_of_range& e) {
68359       {
68360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68361       };
68362     } catch (std::exception& e) {
68363       {
68364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68365       };
68366     } catch (...) {
68367       {
68368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68369       };
68370     }
68371   }
68372   jresult = (void *)result;
68373   return jresult;
68374 }
68375
68376
68377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68378   void * jresult ;
68379   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68380   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68381
68382   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68383   {
68384     try {
68385       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68386     } catch (std::out_of_range& e) {
68387       {
68388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68389       };
68390     } catch (std::exception& e) {
68391       {
68392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68393       };
68394     } catch (...) {
68395       {
68396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68397       };
68398     }
68399   }
68400   jresult = (void *)result;
68401   return jresult;
68402 }
68403
68404
68405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68406   unsigned int jresult ;
68407   Dali::Toolkit::ControlOrientation::Type arg1 ;
68408   bool result;
68409
68410   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68411   {
68412     try {
68413       result = (bool)Dali::Toolkit::IsVertical(arg1);
68414     } catch (std::out_of_range& e) {
68415       {
68416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68417       };
68418     } catch (std::exception& e) {
68419       {
68420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68421       };
68422     } catch (...) {
68423       {
68424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68425       };
68426     }
68427   }
68428   jresult = result;
68429   return jresult;
68430 }
68431
68432
68433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68434   unsigned int jresult ;
68435   Dali::Toolkit::ControlOrientation::Type arg1 ;
68436   bool result;
68437
68438   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68439   {
68440     try {
68441       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68442     } catch (std::out_of_range& e) {
68443       {
68444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68445       };
68446     } catch (std::exception& e) {
68447       {
68448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68449       };
68450     } catch (...) {
68451       {
68452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68453       };
68454     }
68455   }
68456   jresult = result;
68457   return jresult;
68458 }
68459
68460
68461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68462   void * jresult ;
68463   unsigned int arg1 ;
68464   unsigned int arg2 ;
68465   Dali::Toolkit::ItemRange *result = 0 ;
68466
68467   arg1 = (unsigned int)jarg1;
68468   arg2 = (unsigned int)jarg2;
68469   {
68470     try {
68471       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68472     } catch (std::out_of_range& e) {
68473       {
68474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68475       };
68476     } catch (std::exception& e) {
68477       {
68478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68479       };
68480     } catch (...) {
68481       {
68482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68483       };
68484     }
68485   }
68486   jresult = (void *)result;
68487   return jresult;
68488 }
68489
68490
68491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68492   void * jresult ;
68493   Dali::Toolkit::ItemRange *arg1 = 0 ;
68494   Dali::Toolkit::ItemRange *result = 0 ;
68495
68496   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68497   if (!arg1) {
68498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68499     return 0;
68500   }
68501   {
68502     try {
68503       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68504     } catch (std::out_of_range& e) {
68505       {
68506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68507       };
68508     } catch (std::exception& e) {
68509       {
68510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68511       };
68512     } catch (...) {
68513       {
68514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68515       };
68516     }
68517   }
68518   jresult = (void *)result;
68519   return jresult;
68520 }
68521
68522
68523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68524   void * jresult ;
68525   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68526   Dali::Toolkit::ItemRange *arg2 = 0 ;
68527   Dali::Toolkit::ItemRange *result = 0 ;
68528
68529   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68530   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68531   if (!arg2) {
68532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68533     return 0;
68534   }
68535   {
68536     try {
68537       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
68538     } catch (std::out_of_range& e) {
68539       {
68540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68541       };
68542     } catch (std::exception& e) {
68543       {
68544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68545       };
68546     } catch (...) {
68547       {
68548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68549       };
68550     }
68551   }
68552   jresult = (void *)result;
68553   return jresult;
68554 }
68555
68556
68557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68558   unsigned int jresult ;
68559   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68560   unsigned int arg2 ;
68561   bool result;
68562
68563   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68564   arg2 = (unsigned int)jarg2;
68565   {
68566     try {
68567       result = (bool)(arg1)->Within(arg2);
68568     } catch (std::out_of_range& e) {
68569       {
68570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68571       };
68572     } catch (std::exception& e) {
68573       {
68574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68575       };
68576     } catch (...) {
68577       {
68578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68579       };
68580     }
68581   }
68582   jresult = result;
68583   return jresult;
68584 }
68585
68586
68587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
68588   void * jresult ;
68589   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68590   Dali::Toolkit::ItemRange *arg2 = 0 ;
68591   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68592
68593   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68594   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68595   if (!arg2) {
68596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68597     return 0;
68598   }
68599   {
68600     try {
68601       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
68602     } catch (std::out_of_range& e) {
68603       {
68604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68605       };
68606     } catch (std::exception& e) {
68607       {
68608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68609       };
68610     } catch (...) {
68611       {
68612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68613       };
68614     }
68615   }
68616   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68617   return jresult;
68618 }
68619
68620
68621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
68622   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68623   unsigned int arg2 ;
68624
68625   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68626   arg2 = (unsigned int)jarg2;
68627   if (arg1) (arg1)->begin = arg2;
68628 }
68629
68630
68631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
68632   unsigned int jresult ;
68633   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68634   unsigned int result;
68635
68636   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68637   result = (unsigned int) ((arg1)->begin);
68638   jresult = result;
68639   return jresult;
68640 }
68641
68642
68643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
68644   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68645   unsigned int arg2 ;
68646
68647   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68648   arg2 = (unsigned int)jarg2;
68649   if (arg1) (arg1)->end = arg2;
68650 }
68651
68652
68653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
68654   unsigned int jresult ;
68655   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68656   unsigned int result;
68657
68658   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68659   result = (unsigned int) ((arg1)->end);
68660   jresult = result;
68661   return jresult;
68662 }
68663
68664
68665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
68666   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68667
68668   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68669   {
68670     try {
68671       delete arg1;
68672     } catch (std::out_of_range& e) {
68673       {
68674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68675       };
68676     } catch (std::exception& e) {
68677       {
68678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68679       };
68680     } catch (...) {
68681       {
68682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68683       };
68684     }
68685   }
68686 }
68687
68688
68689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
68690   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68691
68692   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68693   {
68694     try {
68695       delete arg1;
68696     } catch (std::out_of_range& e) {
68697       {
68698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68699       };
68700     } catch (std::exception& e) {
68701       {
68702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68703       };
68704     } catch (...) {
68705       {
68706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68707       };
68708     }
68709   }
68710 }
68711
68712
68713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
68714   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68715   Dali::Toolkit::ControlOrientation::Type arg2 ;
68716
68717   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68718   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
68719   {
68720     try {
68721       (arg1)->SetOrientation(arg2);
68722     } catch (std::out_of_range& e) {
68723       {
68724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68725       };
68726     } catch (std::exception& e) {
68727       {
68728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68729       };
68730     } catch (...) {
68731       {
68732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68733       };
68734     }
68735   }
68736 }
68737
68738
68739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
68740   int jresult ;
68741   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68742   Dali::Toolkit::ControlOrientation::Type result;
68743
68744   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68745   {
68746     try {
68747       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
68748     } catch (std::out_of_range& e) {
68749       {
68750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68751       };
68752     } catch (std::exception& e) {
68753       {
68754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68755       };
68756     } catch (...) {
68757       {
68758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68759       };
68760     }
68761   }
68762   jresult = (int)result;
68763   return jresult;
68764 }
68765
68766
68767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
68768   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68769   Dali::Property::Map *arg2 = 0 ;
68770
68771   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68772   arg2 = (Dali::Property::Map *)jarg2;
68773   if (!arg2) {
68774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
68775     return ;
68776   }
68777   {
68778     try {
68779       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
68780     } catch (std::out_of_range& e) {
68781       {
68782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68783       };
68784     } catch (std::exception& e) {
68785       {
68786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68787       };
68788     } catch (...) {
68789       {
68790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68791       };
68792     }
68793   }
68794 }
68795
68796
68797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
68798   void * jresult ;
68799   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68800   Dali::Property::Map result;
68801
68802   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68803   {
68804     try {
68805       result = (arg1)->GetLayoutProperties();
68806     } catch (std::out_of_range& e) {
68807       {
68808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68809       };
68810     } catch (std::exception& e) {
68811       {
68812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68813       };
68814     } catch (...) {
68815       {
68816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68817       };
68818     }
68819   }
68820   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
68821   return jresult;
68822 }
68823
68824
68825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
68826   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68827   unsigned int arg2 ;
68828   Dali::Vector3 *arg3 = 0 ;
68829   Dali::Vector3 *arg4 = 0 ;
68830
68831   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68832   arg2 = (unsigned int)jarg2;
68833   arg3 = (Dali::Vector3 *)jarg3;
68834   if (!arg3) {
68835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68836     return ;
68837   }
68838   arg4 = (Dali::Vector3 *)jarg4;
68839   if (!arg4) {
68840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
68841     return ;
68842   }
68843   {
68844     try {
68845       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
68846     } catch (std::out_of_range& e) {
68847       {
68848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68849       };
68850     } catch (std::exception& e) {
68851       {
68852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68853       };
68854     } catch (...) {
68855       {
68856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68857       };
68858     }
68859   }
68860 }
68861
68862
68863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
68864   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68865   Dali::Vector3 *arg2 = 0 ;
68866
68867   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68868   arg2 = (Dali::Vector3 *)jarg2;
68869   if (!arg2) {
68870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
68871     return ;
68872   }
68873   {
68874     try {
68875       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
68876     } catch (std::out_of_range& e) {
68877       {
68878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68879       };
68880     } catch (std::exception& e) {
68881       {
68882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68883       };
68884     } catch (...) {
68885       {
68886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68887       };
68888     }
68889   }
68890 }
68891
68892
68893 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
68894   float jresult ;
68895   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68896   unsigned int arg2 ;
68897   Dali::Vector3 arg3 ;
68898   Dali::Vector3 *argp3 ;
68899   float result;
68900
68901   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68902   arg2 = (unsigned int)jarg2;
68903   argp3 = (Dali::Vector3 *)jarg3;
68904   if (!argp3) {
68905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
68906     return 0;
68907   }
68908   arg3 = *argp3;
68909   {
68910     try {
68911       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
68912     } catch (std::out_of_range& e) {
68913       {
68914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68915       };
68916     } catch (std::exception& e) {
68917       {
68918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68919       };
68920     } catch (...) {
68921       {
68922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68923       };
68924     }
68925   }
68926   jresult = result;
68927   return jresult;
68928 }
68929
68930
68931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
68932   float jresult ;
68933   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68934   float arg2 ;
68935   float result;
68936
68937   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68938   arg2 = (float)jarg2;
68939   {
68940     try {
68941       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
68942     } catch (std::out_of_range& e) {
68943       {
68944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68945       };
68946     } catch (std::exception& e) {
68947       {
68948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68949       };
68950     } catch (...) {
68951       {
68952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68953       };
68954     }
68955   }
68956   jresult = result;
68957   return jresult;
68958 }
68959
68960
68961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
68962   float jresult ;
68963   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68964   unsigned int arg2 ;
68965   float result;
68966
68967   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
68968   arg2 = (unsigned int)jarg2;
68969   {
68970     try {
68971       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
68972     } catch (std::out_of_range& e) {
68973       {
68974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68975       };
68976     } catch (std::exception& e) {
68977       {
68978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68979       };
68980     } catch (...) {
68981       {
68982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68983       };
68984     }
68985   }
68986   jresult = result;
68987   return jresult;
68988 }
68989
68990
68991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
68992   void * jresult ;
68993   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
68994   float arg2 ;
68995   Dali::Vector3 arg3 ;
68996   Dali::Vector3 *argp3 ;
68997   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68998
68999   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69000   arg2 = (float)jarg2;
69001   argp3 = (Dali::Vector3 *)jarg3;
69002   if (!argp3) {
69003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69004     return 0;
69005   }
69006   arg3 = *argp3;
69007   {
69008     try {
69009       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69010     } catch (std::out_of_range& e) {
69011       {
69012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69013       };
69014     } catch (std::exception& e) {
69015       {
69016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69017       };
69018     } catch (...) {
69019       {
69020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69021       };
69022     }
69023   }
69024   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69025   return jresult;
69026 }
69027
69028
69029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69030   float jresult ;
69031   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69032   int arg2 ;
69033   float arg3 ;
69034   Dali::Vector3 *arg4 = 0 ;
69035   float result;
69036
69037   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69038   arg2 = (int)jarg2;
69039   arg3 = (float)jarg3;
69040   arg4 = (Dali::Vector3 *)jarg4;
69041   if (!arg4) {
69042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69043     return 0;
69044   }
69045   {
69046     try {
69047       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69048     } catch (std::out_of_range& e) {
69049       {
69050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69051       };
69052     } catch (std::exception& e) {
69053       {
69054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69055       };
69056     } catch (...) {
69057       {
69058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69059       };
69060     }
69061   }
69062   jresult = result;
69063   return jresult;
69064 }
69065
69066
69067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69068   unsigned int jresult ;
69069   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69070   Dali::Vector3 arg2 ;
69071   Dali::Vector3 *argp2 ;
69072   unsigned int result;
69073
69074   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69075   argp2 = (Dali::Vector3 *)jarg2;
69076   if (!argp2) {
69077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69078     return 0;
69079   }
69080   arg2 = *argp2;
69081   {
69082     try {
69083       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69084     } catch (std::out_of_range& e) {
69085       {
69086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69087       };
69088     } catch (std::exception& e) {
69089       {
69090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69091       };
69092     } catch (...) {
69093       {
69094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69095       };
69096     }
69097   }
69098   jresult = result;
69099   return jresult;
69100 }
69101
69102
69103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69104   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69105   unsigned int arg2 ;
69106   Dali::Vector3 *arg3 = 0 ;
69107   Dali::Vector3 *arg4 = 0 ;
69108
69109   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69110   arg2 = (unsigned int)jarg2;
69111   arg3 = (Dali::Vector3 *)jarg3;
69112   if (!arg3) {
69113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69114     return ;
69115   }
69116   arg4 = (Dali::Vector3 *)jarg4;
69117   if (!arg4) {
69118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69119     return ;
69120   }
69121   {
69122     try {
69123       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69124     } catch (std::out_of_range& e) {
69125       {
69126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69127       };
69128     } catch (std::exception& e) {
69129       {
69130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69131       };
69132     } catch (...) {
69133       {
69134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69135       };
69136     }
69137   }
69138 }
69139
69140
69141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69142   void * jresult ;
69143   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69144   Dali::Degree result;
69145
69146   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69147   {
69148     try {
69149       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69150     } catch (std::out_of_range& e) {
69151       {
69152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69153       };
69154     } catch (std::exception& e) {
69155       {
69156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69157       };
69158     } catch (...) {
69159       {
69160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69161       };
69162     }
69163   }
69164   jresult = new Dali::Degree((const Dali::Degree &)result);
69165   return jresult;
69166 }
69167
69168
69169 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69170   float jresult ;
69171   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69172   float result;
69173
69174   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69175   {
69176     try {
69177       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69178     } catch (std::out_of_range& e) {
69179       {
69180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69181       };
69182     } catch (std::exception& e) {
69183       {
69184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69185       };
69186     } catch (...) {
69187       {
69188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69189       };
69190     }
69191   }
69192   jresult = result;
69193   return jresult;
69194 }
69195
69196
69197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69198   float jresult ;
69199   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69200   float result;
69201
69202   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69203   {
69204     try {
69205       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69206     } catch (std::out_of_range& e) {
69207       {
69208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69209       };
69210     } catch (std::exception& e) {
69211       {
69212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69213       };
69214     } catch (...) {
69215       {
69216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69217       };
69218     }
69219   }
69220   jresult = result;
69221   return jresult;
69222 }
69223
69224
69225 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69226   float jresult ;
69227   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69228   float result;
69229
69230   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69231   {
69232     try {
69233       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69234     } catch (std::out_of_range& e) {
69235       {
69236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69237       };
69238     } catch (std::exception& e) {
69239       {
69240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69241       };
69242     } catch (...) {
69243       {
69244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69245       };
69246     }
69247   }
69248   jresult = result;
69249   return jresult;
69250 }
69251
69252
69253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69254   int jresult ;
69255   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69256   int arg2 ;
69257   int arg3 ;
69258   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69259   bool arg5 ;
69260   int result;
69261
69262   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69263   arg2 = (int)jarg2;
69264   arg3 = (int)jarg3;
69265   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69266   arg5 = jarg5 ? true : false;
69267   {
69268     try {
69269       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69270     } catch (std::out_of_range& e) {
69271       {
69272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69273       };
69274     } catch (std::exception& e) {
69275       {
69276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69277       };
69278     } catch (...) {
69279       {
69280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69281       };
69282     }
69283   }
69284   jresult = result;
69285   return jresult;
69286 }
69287
69288
69289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69290   float jresult ;
69291   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69292   float result;
69293
69294   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69295   {
69296     try {
69297       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69298     } catch (std::out_of_range& e) {
69299       {
69300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69301       };
69302     } catch (std::exception& e) {
69303       {
69304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69305       };
69306     } catch (...) {
69307       {
69308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69309       };
69310     }
69311   }
69312   jresult = result;
69313   return jresult;
69314 }
69315
69316
69317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69318   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69319   Dali::Actor *arg2 = 0 ;
69320   int arg3 ;
69321   Dali::Vector3 *arg4 = 0 ;
69322   Dali::Actor *arg5 = 0 ;
69323
69324   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69325   arg2 = (Dali::Actor *)jarg2;
69326   if (!arg2) {
69327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69328     return ;
69329   }
69330   arg3 = (int)jarg3;
69331   arg4 = (Dali::Vector3 *)jarg4;
69332   if (!arg4) {
69333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69334     return ;
69335   }
69336   arg5 = (Dali::Actor *)jarg5;
69337   if (!arg5) {
69338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69339     return ;
69340   }
69341   {
69342     try {
69343       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69344     } catch (std::out_of_range& e) {
69345       {
69346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69347       };
69348     } catch (std::exception& e) {
69349       {
69350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69351       };
69352     } catch (...) {
69353       {
69354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69355       };
69356     }
69357   }
69358 }
69359
69360
69361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69362   void * jresult ;
69363   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69364   int arg2 ;
69365   float arg3 ;
69366   Dali::Vector3 *arg4 = 0 ;
69367   Dali::Vector3 result;
69368
69369   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69370   arg2 = (int)jarg2;
69371   arg3 = (float)jarg3;
69372   arg4 = (Dali::Vector3 *)jarg4;
69373   if (!arg4) {
69374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69375     return 0;
69376   }
69377   {
69378     try {
69379       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69380     } catch (std::out_of_range& e) {
69381       {
69382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69383       };
69384     } catch (std::exception& e) {
69385       {
69386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69387       };
69388     } catch (...) {
69389       {
69390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69391       };
69392     }
69393   }
69394   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69395   return jresult;
69396 }
69397
69398
69399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
69400   void * jresult ;
69401   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
69402   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69403
69404   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
69405   {
69406     try {
69407       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
69408     } catch (std::out_of_range& e) {
69409       {
69410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69411       };
69412     } catch (std::exception& e) {
69413       {
69414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69415       };
69416     } catch (...) {
69417       {
69418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69419       };
69420     }
69421   }
69422   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69423   return jresult;
69424 }
69425
69426
69427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
69428   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69429
69430   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69431   {
69432     try {
69433       delete arg1;
69434     } catch (std::out_of_range& e) {
69435       {
69436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69437       };
69438     } catch (std::exception& e) {
69439       {
69440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69441       };
69442     } catch (...) {
69443       {
69444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69445       };
69446     }
69447   }
69448 }
69449
69450
69451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
69452   unsigned int jresult ;
69453   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69454   unsigned int result;
69455
69456   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69457   {
69458     try {
69459       result = (unsigned int)(arg1)->GetNumberOfItems();
69460     } catch (std::out_of_range& e) {
69461       {
69462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69463       };
69464     } catch (std::exception& e) {
69465       {
69466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69467       };
69468     } catch (...) {
69469       {
69470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69471       };
69472     }
69473   }
69474   jresult = result;
69475   return jresult;
69476 }
69477
69478
69479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
69480   void * jresult ;
69481   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69482   unsigned int arg2 ;
69483   Dali::Actor result;
69484
69485   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69486   arg2 = (unsigned int)jarg2;
69487   {
69488     try {
69489       result = (arg1)->NewItem(arg2);
69490     } catch (std::out_of_range& e) {
69491       {
69492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69493       };
69494     } catch (std::exception& e) {
69495       {
69496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69497       };
69498     } catch (...) {
69499       {
69500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69501       };
69502     }
69503   }
69504   jresult = new Dali::Actor((const Dali::Actor &)result);
69505   return jresult;
69506 }
69507
69508
69509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
69510   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69511   unsigned int arg2 ;
69512   Dali::Actor arg3 ;
69513   Dali::Actor *argp3 ;
69514
69515   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69516   arg2 = (unsigned int)jarg2;
69517   argp3 = (Dali::Actor *)jarg3;
69518   if (!argp3) {
69519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69520     return ;
69521   }
69522   arg3 = *argp3;
69523   {
69524     try {
69525       (arg1)->ItemReleased(arg2,arg3);
69526     } catch (std::out_of_range& e) {
69527       {
69528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69529       };
69530     } catch (std::exception& e) {
69531       {
69532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69533       };
69534     } catch (...) {
69535       {
69536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69537       };
69538     }
69539   }
69540 }
69541
69542
69543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
69544   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69545   unsigned int arg2 ;
69546   Dali::Actor arg3 ;
69547   Dali::Actor *argp3 ;
69548
69549   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69550   arg2 = (unsigned int)jarg2;
69551   argp3 = (Dali::Actor *)jarg3;
69552   if (!argp3) {
69553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69554     return ;
69555   }
69556   arg3 = *argp3;
69557   {
69558     try {
69559       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
69560     } catch (std::out_of_range& e) {
69561       {
69562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69563       };
69564     } catch (std::exception& e) {
69565       {
69566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69567       };
69568     } catch (...) {
69569       {
69570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69571       };
69572     }
69573   }
69574 }
69575
69576
69577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
69578   void * jresult ;
69579   Dali::Toolkit::ItemFactory *result = 0 ;
69580
69581   {
69582     try {
69583       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
69584     } catch (std::out_of_range& e) {
69585       {
69586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69587       };
69588     } catch (std::exception& e) {
69589       {
69590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69591       };
69592     } catch (...) {
69593       {
69594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69595       };
69596     }
69597   }
69598   jresult = (void *)result;
69599   return jresult;
69600 }
69601
69602
69603 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) {
69604   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
69605   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
69606   if (director) {
69607     director->swig_connect_director(callback0, callback1, callback2);
69608   }
69609 }
69610
69611
69612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
69613   int jresult ;
69614   int result;
69615
69616   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
69617   jresult = (int)result;
69618   return jresult;
69619 }
69620
69621
69622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
69623   int jresult ;
69624   int result;
69625
69626   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
69627   jresult = (int)result;
69628   return jresult;
69629 }
69630
69631
69632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
69633   int jresult ;
69634   int result;
69635
69636   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
69637   jresult = (int)result;
69638   return jresult;
69639 }
69640
69641
69642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
69643   int jresult ;
69644   int result;
69645
69646   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
69647   jresult = (int)result;
69648   return jresult;
69649 }
69650
69651
69652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
69653   int jresult ;
69654   int result;
69655
69656   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
69657   jresult = (int)result;
69658   return jresult;
69659 }
69660
69661
69662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
69663   int jresult ;
69664   int result;
69665
69666   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
69667   jresult = (int)result;
69668   return jresult;
69669 }
69670
69671
69672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
69673   int jresult ;
69674   int result;
69675
69676   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
69677   jresult = (int)result;
69678   return jresult;
69679 }
69680
69681
69682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
69683   int jresult ;
69684   int result;
69685
69686   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
69687   jresult = (int)result;
69688   return jresult;
69689 }
69690
69691
69692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
69693   int jresult ;
69694   int result;
69695
69696   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
69697   jresult = (int)result;
69698   return jresult;
69699 }
69700
69701
69702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
69703   int jresult ;
69704   int result;
69705
69706   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
69707   jresult = (int)result;
69708   return jresult;
69709 }
69710
69711
69712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
69713   int jresult ;
69714   int result;
69715
69716   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
69717   jresult = (int)result;
69718   return jresult;
69719 }
69720
69721
69722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
69723   void * jresult ;
69724   Dali::Toolkit::ItemView::Property *result = 0 ;
69725
69726   {
69727     try {
69728       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
69729     } catch (std::out_of_range& e) {
69730       {
69731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69732       };
69733     } catch (std::exception& e) {
69734       {
69735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69736       };
69737     } catch (...) {
69738       {
69739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69740       };
69741     }
69742   }
69743   jresult = (void *)result;
69744   return jresult;
69745 }
69746
69747
69748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
69749   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
69750
69751   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
69752   {
69753     try {
69754       delete arg1;
69755     } catch (std::out_of_range& e) {
69756       {
69757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69758       };
69759     } catch (std::exception& e) {
69760       {
69761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69762       };
69763     } catch (...) {
69764       {
69765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69766       };
69767     }
69768   }
69769 }
69770
69771
69772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
69773   void * jresult ;
69774   Dali::Toolkit::ItemView *result = 0 ;
69775
69776   {
69777     try {
69778       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
69779     } catch (std::out_of_range& e) {
69780       {
69781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69782       };
69783     } catch (std::exception& e) {
69784       {
69785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69786       };
69787     } catch (...) {
69788       {
69789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69790       };
69791     }
69792   }
69793   jresult = (void *)result;
69794   return jresult;
69795 }
69796
69797
69798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
69799   void * jresult ;
69800   Dali::Toolkit::ItemView *arg1 = 0 ;
69801   Dali::Toolkit::ItemView *result = 0 ;
69802
69803   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69804   if (!arg1) {
69805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69806     return 0;
69807   }
69808   {
69809     try {
69810       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
69811     } catch (std::out_of_range& e) {
69812       {
69813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69814       };
69815     } catch (std::exception& e) {
69816       {
69817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69818       };
69819     } catch (...) {
69820       {
69821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69822       };
69823     }
69824   }
69825   jresult = (void *)result;
69826   return jresult;
69827 }
69828
69829
69830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
69831   void * jresult ;
69832   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69833   Dali::Toolkit::ItemView *arg2 = 0 ;
69834   Dali::Toolkit::ItemView *result = 0 ;
69835
69836   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69837   arg2 = (Dali::Toolkit::ItemView *)jarg2;
69838   if (!arg2) {
69839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
69840     return 0;
69841   }
69842   {
69843     try {
69844       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
69845     } catch (std::out_of_range& e) {
69846       {
69847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69848       };
69849     } catch (std::exception& e) {
69850       {
69851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69852       };
69853     } catch (...) {
69854       {
69855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69856       };
69857     }
69858   }
69859   jresult = (void *)result;
69860   return jresult;
69861 }
69862
69863
69864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
69865   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69866
69867   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69868   {
69869     try {
69870       delete arg1;
69871     } catch (std::out_of_range& e) {
69872       {
69873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69874       };
69875     } catch (std::exception& e) {
69876       {
69877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69878       };
69879     } catch (...) {
69880       {
69881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69882       };
69883     }
69884   }
69885 }
69886
69887
69888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
69889   void * jresult ;
69890   Dali::Toolkit::ItemFactory *arg1 = 0 ;
69891   Dali::Toolkit::ItemView result;
69892
69893   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69894   if (!arg1) {
69895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
69896     return 0;
69897   }
69898   {
69899     try {
69900       result = Dali::Toolkit::ItemView::New(*arg1);
69901     } catch (std::out_of_range& e) {
69902       {
69903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69904       };
69905     } catch (std::exception& e) {
69906       {
69907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69908       };
69909     } catch (...) {
69910       {
69911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69912       };
69913     }
69914   }
69915   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69916   return jresult;
69917 }
69918
69919
69920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
69921   void * jresult ;
69922   Dali::BaseHandle arg1 ;
69923   Dali::BaseHandle *argp1 ;
69924   Dali::Toolkit::ItemView result;
69925
69926   argp1 = (Dali::BaseHandle *)jarg1;
69927   if (!argp1) {
69928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69929     return 0;
69930   }
69931   arg1 = *argp1;
69932   {
69933     try {
69934       result = Dali::Toolkit::ItemView::DownCast(arg1);
69935     } catch (std::out_of_range& e) {
69936       {
69937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69938       };
69939     } catch (std::exception& e) {
69940       {
69941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69942       };
69943     } catch (...) {
69944       {
69945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69946       };
69947     }
69948   }
69949   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
69950   return jresult;
69951 }
69952
69953
69954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
69955   unsigned int jresult ;
69956   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69957   unsigned int result;
69958
69959   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69960   {
69961     try {
69962       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
69963     } catch (std::out_of_range& e) {
69964       {
69965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69966       };
69967     } catch (std::exception& e) {
69968       {
69969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69970       };
69971     } catch (...) {
69972       {
69973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69974       };
69975     }
69976   }
69977   jresult = result;
69978   return jresult;
69979 }
69980
69981
69982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
69983   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
69984   Dali::Toolkit::ItemLayout *arg2 = 0 ;
69985
69986   arg1 = (Dali::Toolkit::ItemView *)jarg1;
69987   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
69988   if (!arg2) {
69989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
69990     return ;
69991   }
69992   {
69993     try {
69994       (arg1)->AddLayout(*arg2);
69995     } catch (std::out_of_range& e) {
69996       {
69997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69998       };
69999     } catch (std::exception& e) {
70000       {
70001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70002       };
70003     } catch (...) {
70004       {
70005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70006       };
70007     }
70008   }
70009 }
70010
70011
70012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70013   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70014   unsigned int arg2 ;
70015
70016   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70017   arg2 = (unsigned int)jarg2;
70018   {
70019     try {
70020       (arg1)->RemoveLayout(arg2);
70021     } catch (std::out_of_range& e) {
70022       {
70023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70024       };
70025     } catch (std::exception& e) {
70026       {
70027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70028       };
70029     } catch (...) {
70030       {
70031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70032       };
70033     }
70034   }
70035 }
70036
70037
70038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70039   void * jresult ;
70040   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70041   unsigned int arg2 ;
70042   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70043
70044   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70045   arg2 = (unsigned int)jarg2;
70046   {
70047     try {
70048       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70049     } catch (std::out_of_range& e) {
70050       {
70051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70052       };
70053     } catch (std::exception& e) {
70054       {
70055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70056       };
70057     } catch (...) {
70058       {
70059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70060       };
70061     }
70062   }
70063   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70064   return jresult;
70065 }
70066
70067
70068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70069   void * jresult ;
70070   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70071   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70072
70073   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70074   {
70075     try {
70076       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70077     } catch (std::out_of_range& e) {
70078       {
70079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70080       };
70081     } catch (std::exception& e) {
70082       {
70083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70084       };
70085     } catch (...) {
70086       {
70087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70088       };
70089     }
70090   }
70091   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70092   return jresult;
70093 }
70094
70095
70096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70097   float jresult ;
70098   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70099   Dali::Toolkit::ItemId arg2 ;
70100   float result;
70101
70102   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70103   arg2 = (Dali::Toolkit::ItemId)jarg2;
70104   {
70105     try {
70106       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70107     } catch (std::out_of_range& e) {
70108       {
70109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70110       };
70111     } catch (std::exception& e) {
70112       {
70113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70114       };
70115     } catch (...) {
70116       {
70117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70118       };
70119     }
70120   }
70121   jresult = result;
70122   return jresult;
70123 }
70124
70125
70126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70127   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70128   unsigned int arg2 ;
70129   Dali::Vector3 arg3 ;
70130   float arg4 ;
70131   Dali::Vector3 *argp3 ;
70132
70133   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70134   arg2 = (unsigned int)jarg2;
70135   argp3 = (Dali::Vector3 *)jarg3;
70136   if (!argp3) {
70137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70138     return ;
70139   }
70140   arg3 = *argp3;
70141   arg4 = (float)jarg4;
70142   {
70143     try {
70144       (arg1)->ActivateLayout(arg2,arg3,arg4);
70145     } catch (std::out_of_range& e) {
70146       {
70147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70148       };
70149     } catch (std::exception& e) {
70150       {
70151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70152       };
70153     } catch (...) {
70154       {
70155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70156       };
70157     }
70158   }
70159 }
70160
70161
70162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70163   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70164
70165   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70166   {
70167     try {
70168       (arg1)->DeactivateCurrentLayout();
70169     } catch (std::out_of_range& e) {
70170       {
70171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70172       };
70173     } catch (std::exception& e) {
70174       {
70175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70176       };
70177     } catch (...) {
70178       {
70179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70180       };
70181     }
70182   }
70183 }
70184
70185
70186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70187   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70188   float arg2 ;
70189
70190   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70191   arg2 = (float)jarg2;
70192   {
70193     try {
70194       (arg1)->SetMinimumSwipeSpeed(arg2);
70195     } catch (std::out_of_range& e) {
70196       {
70197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70198       };
70199     } catch (std::exception& e) {
70200       {
70201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70202       };
70203     } catch (...) {
70204       {
70205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70206       };
70207     }
70208   }
70209 }
70210
70211
70212 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70213   float jresult ;
70214   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70215   float result;
70216
70217   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70218   {
70219     try {
70220       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70221     } catch (std::out_of_range& e) {
70222       {
70223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70224       };
70225     } catch (std::exception& e) {
70226       {
70227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70228       };
70229     } catch (...) {
70230       {
70231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70232       };
70233     }
70234   }
70235   jresult = result;
70236   return jresult;
70237 }
70238
70239
70240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70241   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70242   float arg2 ;
70243
70244   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70245   arg2 = (float)jarg2;
70246   {
70247     try {
70248       (arg1)->SetMinimumSwipeDistance(arg2);
70249     } catch (std::out_of_range& e) {
70250       {
70251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70252       };
70253     } catch (std::exception& e) {
70254       {
70255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70256       };
70257     } catch (...) {
70258       {
70259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70260       };
70261     }
70262   }
70263 }
70264
70265
70266 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70267   float jresult ;
70268   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70269   float result;
70270
70271   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70272   {
70273     try {
70274       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70275     } catch (std::out_of_range& e) {
70276       {
70277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70278       };
70279     } catch (std::exception& e) {
70280       {
70281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70282       };
70283     } catch (...) {
70284       {
70285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70286       };
70287     }
70288   }
70289   jresult = result;
70290   return jresult;
70291 }
70292
70293
70294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
70295   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70296   float arg2 ;
70297
70298   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70299   arg2 = (float)jarg2;
70300   {
70301     try {
70302       (arg1)->SetWheelScrollDistanceStep(arg2);
70303     } catch (std::out_of_range& e) {
70304       {
70305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70306       };
70307     } catch (std::exception& e) {
70308       {
70309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70310       };
70311     } catch (...) {
70312       {
70313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70314       };
70315     }
70316   }
70317 }
70318
70319
70320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
70321   float jresult ;
70322   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70323   float result;
70324
70325   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70326   {
70327     try {
70328       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
70329     } catch (std::out_of_range& e) {
70330       {
70331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70332       };
70333     } catch (std::exception& e) {
70334       {
70335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70336       };
70337     } catch (...) {
70338       {
70339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70340       };
70341     }
70342   }
70343   jresult = result;
70344   return jresult;
70345 }
70346
70347
70348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
70349   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70350   bool arg2 ;
70351
70352   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70353   arg2 = jarg2 ? true : false;
70354   {
70355     try {
70356       (arg1)->SetAnchoring(arg2);
70357     } catch (std::out_of_range& e) {
70358       {
70359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70360       };
70361     } catch (std::exception& e) {
70362       {
70363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70364       };
70365     } catch (...) {
70366       {
70367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70368       };
70369     }
70370   }
70371 }
70372
70373
70374 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
70375   unsigned int jresult ;
70376   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70377   bool result;
70378
70379   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70380   {
70381     try {
70382       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
70383     } catch (std::out_of_range& e) {
70384       {
70385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70386       };
70387     } catch (std::exception& e) {
70388       {
70389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70390       };
70391     } catch (...) {
70392       {
70393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70394       };
70395     }
70396   }
70397   jresult = result;
70398   return jresult;
70399 }
70400
70401
70402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
70403   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70404   float arg2 ;
70405
70406   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70407   arg2 = (float)jarg2;
70408   {
70409     try {
70410       (arg1)->SetAnchoringDuration(arg2);
70411     } catch (std::out_of_range& e) {
70412       {
70413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70414       };
70415     } catch (std::exception& e) {
70416       {
70417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70418       };
70419     } catch (...) {
70420       {
70421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70422       };
70423     }
70424   }
70425 }
70426
70427
70428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
70429   float jresult ;
70430   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70431   float result;
70432
70433   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70434   {
70435     try {
70436       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
70437     } catch (std::out_of_range& e) {
70438       {
70439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70440       };
70441     } catch (std::exception& e) {
70442       {
70443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70444       };
70445     } catch (...) {
70446       {
70447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70448       };
70449     }
70450   }
70451   jresult = result;
70452   return jresult;
70453 }
70454
70455
70456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
70457   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70458   Dali::Toolkit::ItemId arg2 ;
70459   float arg3 ;
70460
70461   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70462   arg2 = (Dali::Toolkit::ItemId)jarg2;
70463   arg3 = (float)jarg3;
70464   {
70465     try {
70466       (arg1)->ScrollToItem(arg2,arg3);
70467     } catch (std::out_of_range& e) {
70468       {
70469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70470       };
70471     } catch (std::exception& e) {
70472       {
70473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70474       };
70475     } catch (...) {
70476       {
70477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70478       };
70479     }
70480   }
70481 }
70482
70483
70484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
70485   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70486   float arg2 ;
70487
70488   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70489   arg2 = (float)jarg2;
70490   {
70491     try {
70492       (arg1)->SetRefreshInterval(arg2);
70493     } catch (std::out_of_range& e) {
70494       {
70495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70496       };
70497     } catch (std::exception& e) {
70498       {
70499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70500       };
70501     } catch (...) {
70502       {
70503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70504       };
70505     }
70506   }
70507 }
70508
70509
70510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
70511   float jresult ;
70512   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70513   float result;
70514
70515   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70516   {
70517     try {
70518       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
70519     } catch (std::out_of_range& e) {
70520       {
70521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70522       };
70523     } catch (std::exception& e) {
70524       {
70525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70526       };
70527     } catch (...) {
70528       {
70529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70530       };
70531     }
70532   }
70533   jresult = result;
70534   return jresult;
70535 }
70536
70537
70538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
70539   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70540
70541   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70542   {
70543     try {
70544       (arg1)->Refresh();
70545     } catch (std::out_of_range& e) {
70546       {
70547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70548       };
70549     } catch (std::exception& e) {
70550       {
70551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70552       };
70553     } catch (...) {
70554       {
70555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70556       };
70557     }
70558   }
70559 }
70560
70561
70562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
70563   void * jresult ;
70564   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70565   Dali::Toolkit::ItemId arg2 ;
70566   Dali::Actor result;
70567
70568   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70569   arg2 = (Dali::Toolkit::ItemId)jarg2;
70570   {
70571     try {
70572       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
70573     } catch (std::out_of_range& e) {
70574       {
70575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70576       };
70577     } catch (std::exception& e) {
70578       {
70579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70580       };
70581     } catch (...) {
70582       {
70583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70584       };
70585     }
70586   }
70587   jresult = new Dali::Actor((const Dali::Actor &)result);
70588   return jresult;
70589 }
70590
70591
70592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
70593   unsigned int jresult ;
70594   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70595   Dali::Actor arg2 ;
70596   Dali::Actor *argp2 ;
70597   Dali::Toolkit::ItemId result;
70598
70599   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70600   argp2 = (Dali::Actor *)jarg2;
70601   if (!argp2) {
70602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70603     return 0;
70604   }
70605   arg2 = *argp2;
70606   {
70607     try {
70608       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
70609     } catch (std::out_of_range& e) {
70610       {
70611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70612       };
70613     } catch (std::exception& e) {
70614       {
70615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70616       };
70617     } catch (...) {
70618       {
70619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70620       };
70621     }
70622   }
70623   jresult = result;
70624   return jresult;
70625 }
70626
70627
70628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
70629   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70630   Dali::Toolkit::Item arg2 ;
70631   float arg3 ;
70632   Dali::Toolkit::Item *argp2 ;
70633
70634   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70635   argp2 = (Dali::Toolkit::Item *)jarg2;
70636   if (!argp2) {
70637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70638     return ;
70639   }
70640   arg2 = *argp2;
70641   arg3 = (float)jarg3;
70642   {
70643     try {
70644       (arg1)->InsertItem(arg2,arg3);
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_InsertItems(void * jarg1, void * jarg2, float jarg3) {
70663   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70664   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70665   float arg3 ;
70666
70667   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70668   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70669   if (!arg2) {
70670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70671     return ;
70672   }
70673   arg3 = (float)jarg3;
70674   {
70675     try {
70676       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70677     } catch (std::out_of_range& e) {
70678       {
70679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70680       };
70681     } catch (std::exception& e) {
70682       {
70683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70684       };
70685     } catch (...) {
70686       {
70687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70688       };
70689     }
70690   }
70691 }
70692
70693
70694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
70695   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70696   Dali::Toolkit::ItemId arg2 ;
70697   float arg3 ;
70698
70699   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70700   arg2 = (Dali::Toolkit::ItemId)jarg2;
70701   arg3 = (float)jarg3;
70702   {
70703     try {
70704       (arg1)->RemoveItem(arg2,arg3);
70705     } catch (std::out_of_range& e) {
70706       {
70707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70708       };
70709     } catch (std::exception& e) {
70710       {
70711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70712       };
70713     } catch (...) {
70714       {
70715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70716       };
70717     }
70718   }
70719 }
70720
70721
70722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
70723   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70724   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
70725   float arg3 ;
70726
70727   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70728   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
70729   if (!arg2) {
70730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
70731     return ;
70732   }
70733   arg3 = (float)jarg3;
70734   {
70735     try {
70736       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
70737     } catch (std::out_of_range& e) {
70738       {
70739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70740       };
70741     } catch (std::exception& e) {
70742       {
70743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70744       };
70745     } catch (...) {
70746       {
70747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70748       };
70749     }
70750   }
70751 }
70752
70753
70754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
70755   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70756   Dali::Toolkit::Item arg2 ;
70757   float arg3 ;
70758   Dali::Toolkit::Item *argp2 ;
70759
70760   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70761   argp2 = (Dali::Toolkit::Item *)jarg2;
70762   if (!argp2) {
70763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
70764     return ;
70765   }
70766   arg2 = *argp2;
70767   arg3 = (float)jarg3;
70768   {
70769     try {
70770       (arg1)->ReplaceItem(arg2,arg3);
70771     } catch (std::out_of_range& e) {
70772       {
70773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70774       };
70775     } catch (std::exception& e) {
70776       {
70777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70778       };
70779     } catch (...) {
70780       {
70781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70782       };
70783     }
70784   }
70785 }
70786
70787
70788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
70789   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70790   Dali::Toolkit::ItemContainer *arg2 = 0 ;
70791   float arg3 ;
70792
70793   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70794   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
70795   if (!arg2) {
70796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
70797     return ;
70798   }
70799   arg3 = (float)jarg3;
70800   {
70801     try {
70802       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
70803     } catch (std::out_of_range& e) {
70804       {
70805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70806       };
70807     } catch (std::exception& e) {
70808       {
70809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70810       };
70811     } catch (...) {
70812       {
70813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70814       };
70815     }
70816   }
70817 }
70818
70819
70820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
70821   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70822   Dali::Vector3 *arg2 = 0 ;
70823
70824   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70825   arg2 = (Dali::Vector3 *)jarg2;
70826   if (!arg2) {
70827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70828     return ;
70829   }
70830   {
70831     try {
70832       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
70833     } catch (std::out_of_range& e) {
70834       {
70835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70836       };
70837     } catch (std::exception& e) {
70838       {
70839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70840       };
70841     } catch (...) {
70842       {
70843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70844       };
70845     }
70846   }
70847 }
70848
70849
70850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
70851   void * jresult ;
70852   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70853   Dali::Vector3 result;
70854
70855   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70856   {
70857     try {
70858       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
70859     } catch (std::out_of_range& e) {
70860       {
70861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70862       };
70863     } catch (std::exception& e) {
70864       {
70865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70866       };
70867     } catch (...) {
70868       {
70869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70870       };
70871     }
70872   }
70873   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70874   return jresult;
70875 }
70876
70877
70878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
70879   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70880   Dali::Vector3 *arg2 = 0 ;
70881
70882   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70883   arg2 = (Dali::Vector3 *)jarg2;
70884   if (!arg2) {
70885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70886     return ;
70887   }
70888   {
70889     try {
70890       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
70891     } catch (std::out_of_range& e) {
70892       {
70893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70894       };
70895     } catch (std::exception& e) {
70896       {
70897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70898       };
70899     } catch (...) {
70900       {
70901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70902       };
70903     }
70904   }
70905 }
70906
70907
70908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
70909   void * jresult ;
70910   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70911   Dali::Vector3 result;
70912
70913   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70914   {
70915     try {
70916       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
70917     } catch (std::out_of_range& e) {
70918       {
70919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70920       };
70921     } catch (std::exception& e) {
70922       {
70923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70924       };
70925     } catch (...) {
70926       {
70927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70928       };
70929     }
70930   }
70931   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70932   return jresult;
70933 }
70934
70935
70936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
70937   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70938   Dali::Toolkit::ItemRange *arg2 = 0 ;
70939
70940   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70941   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
70942   if (!arg2) {
70943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
70944     return ;
70945   }
70946   {
70947     try {
70948       (arg1)->GetItemsRange(*arg2);
70949     } catch (std::out_of_range& e) {
70950       {
70951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70952       };
70953     } catch (std::exception& e) {
70954       {
70955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70956       };
70957     } catch (...) {
70958       {
70959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70960       };
70961     }
70962   }
70963 }
70964
70965
70966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
70967   void * jresult ;
70968   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70969   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
70970
70971   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70972   {
70973     try {
70974       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
70975     } catch (std::out_of_range& e) {
70976       {
70977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70978       };
70979     } catch (std::exception& e) {
70980       {
70981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70982       };
70983     } catch (...) {
70984       {
70985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70986       };
70987     }
70988   }
70989   jresult = (void *)result;
70990   return jresult;
70991 }
70992
70993
70994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
70995   Dali::Vector3 *arg1 = 0 ;
70996   PropertyInputContainer *arg2 = 0 ;
70997
70998   arg1 = (Dali::Vector3 *)jarg1;
70999   if (!arg1) {
71000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71001     return ;
71002   }
71003   arg2 = (PropertyInputContainer *)jarg2;
71004   if (!arg2) {
71005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71006     return ;
71007   }
71008   {
71009     try {
71010       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71011     } catch (std::out_of_range& e) {
71012       {
71013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71014       };
71015     } catch (std::exception& e) {
71016       {
71017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71018       };
71019     } catch (...) {
71020       {
71021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71022       };
71023     }
71024   }
71025 }
71026
71027
71028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71029   Dali::Vector3 *arg1 = 0 ;
71030   PropertyInputContainer *arg2 = 0 ;
71031
71032   arg1 = (Dali::Vector3 *)jarg1;
71033   if (!arg1) {
71034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71035     return ;
71036   }
71037   arg2 = (PropertyInputContainer *)jarg2;
71038   if (!arg2) {
71039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71040     return ;
71041   }
71042   {
71043     try {
71044       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71045     } catch (std::out_of_range& e) {
71046       {
71047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71048       };
71049     } catch (std::exception& e) {
71050       {
71051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71052       };
71053     } catch (...) {
71054       {
71055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71056       };
71057     }
71058   }
71059 }
71060
71061
71062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
71063   void * jresult ;
71064   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71065
71066   {
71067     try {
71068       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
71069     } catch (std::out_of_range& e) {
71070       {
71071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71072       };
71073     } catch (std::exception& e) {
71074       {
71075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71076       };
71077     } catch (...) {
71078       {
71079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71080       };
71081     }
71082   }
71083   jresult = (void *)result;
71084   return jresult;
71085 }
71086
71087
71088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
71089   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
71090
71091   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
71092   {
71093     try {
71094       delete arg1;
71095     } catch (std::out_of_range& e) {
71096       {
71097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71098       };
71099     } catch (std::exception& e) {
71100       {
71101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71102       };
71103     } catch (...) {
71104       {
71105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71106       };
71107     }
71108   }
71109 }
71110
71111
71112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
71113   void * jresult ;
71114   Dali::Path arg1 ;
71115   Dali::Vector3 *arg2 = 0 ;
71116   Dali::Property::Index arg3 ;
71117   Dali::Vector3 *arg4 = 0 ;
71118   unsigned int arg5 ;
71119   Dali::Path *argp1 ;
71120   Dali::Toolkit::ScrollViewPagePathEffect result;
71121
71122   argp1 = (Dali::Path *)jarg1;
71123   if (!argp1) {
71124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
71125     return 0;
71126   }
71127   arg1 = *argp1;
71128   arg2 = (Dali::Vector3 *)jarg2;
71129   if (!arg2) {
71130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71131     return 0;
71132   }
71133   arg3 = (Dali::Property::Index)jarg3;
71134   arg4 = (Dali::Vector3 *)jarg4;
71135   if (!arg4) {
71136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71137     return 0;
71138   }
71139   arg5 = (unsigned int)jarg5;
71140   {
71141     try {
71142       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
71143     } catch (std::out_of_range& e) {
71144       {
71145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71146       };
71147     } catch (std::exception& e) {
71148       {
71149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71150       };
71151     } catch (...) {
71152       {
71153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71154       };
71155     }
71156   }
71157   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71158   return jresult;
71159 }
71160
71161
71162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
71163   void * jresult ;
71164   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
71165
71166   {
71167     try {
71168       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
71169     } catch (std::out_of_range& e) {
71170       {
71171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71172       };
71173     } catch (std::exception& e) {
71174       {
71175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71176       };
71177     } catch (...) {
71178       {
71179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71180       };
71181     }
71182   }
71183   jresult = (void *)result;
71184   return jresult;
71185 }
71186
71187
71188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
71189   void * jresult ;
71190   Dali::BaseHandle arg1 ;
71191   Dali::BaseHandle *argp1 ;
71192   Dali::Toolkit::ScrollViewPagePathEffect result;
71193
71194   argp1 = (Dali::BaseHandle *)jarg1;
71195   if (!argp1) {
71196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71197     return 0;
71198   }
71199   arg1 = *argp1;
71200   {
71201     try {
71202       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
71203     } catch (std::out_of_range& e) {
71204       {
71205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71206       };
71207     } catch (std::exception& e) {
71208       {
71209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71210       };
71211     } catch (...) {
71212       {
71213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71214       };
71215     }
71216   }
71217   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71218   return jresult;
71219 }
71220
71221
71222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
71223   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71224   Dali::Actor arg2 ;
71225   unsigned int arg3 ;
71226   Dali::Actor *argp2 ;
71227
71228   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71229   argp2 = (Dali::Actor *)jarg2;
71230   if (!argp2) {
71231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71232     return ;
71233   }
71234   arg2 = *argp2;
71235   arg3 = (unsigned int)jarg3;
71236   {
71237     try {
71238       (arg1)->ApplyToPage(arg2,arg3);
71239     } catch (std::out_of_range& e) {
71240       {
71241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71242       };
71243     } catch (std::exception& e) {
71244       {
71245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71246       };
71247     } catch (...) {
71248       {
71249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71250       };
71251     }
71252   }
71253 }
71254
71255
71256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
71257   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71258
71259   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71260   {
71261     try {
71262       delete arg1;
71263     } catch (std::out_of_range& e) {
71264       {
71265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71266       };
71267     } catch (std::exception& e) {
71268       {
71269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71270       };
71271     } catch (...) {
71272       {
71273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71274       };
71275     }
71276   }
71277 }
71278
71279
71280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
71281   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71282   Dali::Toolkit::ClampState arg2 ;
71283
71284   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71285   arg2 = (Dali::Toolkit::ClampState)jarg2;
71286   if (arg1) (arg1)->x = arg2;
71287 }
71288
71289
71290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
71291   int jresult ;
71292   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71293   Dali::Toolkit::ClampState result;
71294
71295   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71296   result = (Dali::Toolkit::ClampState) ((arg1)->x);
71297   jresult = (int)result;
71298   return jresult;
71299 }
71300
71301
71302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
71303   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71304   Dali::Toolkit::ClampState arg2 ;
71305
71306   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71307   arg2 = (Dali::Toolkit::ClampState)jarg2;
71308   if (arg1) (arg1)->y = arg2;
71309 }
71310
71311
71312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
71313   int jresult ;
71314   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71315   Dali::Toolkit::ClampState result;
71316
71317   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71318   result = (Dali::Toolkit::ClampState) ((arg1)->y);
71319   jresult = (int)result;
71320   return jresult;
71321 }
71322
71323
71324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
71325   void * jresult ;
71326   Dali::Toolkit::ClampState2D *result = 0 ;
71327
71328   {
71329     try {
71330       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
71331     } catch (std::out_of_range& e) {
71332       {
71333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71334       };
71335     } catch (std::exception& e) {
71336       {
71337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71338       };
71339     } catch (...) {
71340       {
71341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71342       };
71343     }
71344   }
71345   jresult = (void *)result;
71346   return jresult;
71347 }
71348
71349
71350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
71351   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
71352
71353   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
71354   {
71355     try {
71356       delete arg1;
71357     } catch (std::out_of_range& e) {
71358       {
71359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71360       };
71361     } catch (std::exception& e) {
71362       {
71363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71364       };
71365     } catch (...) {
71366       {
71367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71368       };
71369     }
71370   }
71371 }
71372
71373
71374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
71375   void * jresult ;
71376   float arg1 ;
71377   float arg2 ;
71378   bool arg3 ;
71379   Dali::Toolkit::RulerDomain *result = 0 ;
71380
71381   arg1 = (float)jarg1;
71382   arg2 = (float)jarg2;
71383   arg3 = jarg3 ? true : false;
71384   {
71385     try {
71386       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
71387     } catch (std::out_of_range& e) {
71388       {
71389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71390       };
71391     } catch (std::exception& e) {
71392       {
71393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71394       };
71395     } catch (...) {
71396       {
71397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71398       };
71399     }
71400   }
71401   jresult = (void *)result;
71402   return jresult;
71403 }
71404
71405
71406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
71407   void * jresult ;
71408   float arg1 ;
71409   float arg2 ;
71410   Dali::Toolkit::RulerDomain *result = 0 ;
71411
71412   arg1 = (float)jarg1;
71413   arg2 = (float)jarg2;
71414   {
71415     try {
71416       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
71417     } catch (std::out_of_range& e) {
71418       {
71419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71420       };
71421     } catch (std::exception& e) {
71422       {
71423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71424       };
71425     } catch (...) {
71426       {
71427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71428       };
71429     }
71430   }
71431   jresult = (void *)result;
71432   return jresult;
71433 }
71434
71435
71436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
71437   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71438   float arg2 ;
71439
71440   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71441   arg2 = (float)jarg2;
71442   if (arg1) (arg1)->min = arg2;
71443 }
71444
71445
71446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
71447   float jresult ;
71448   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71449   float result;
71450
71451   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71452   result = (float) ((arg1)->min);
71453   jresult = result;
71454   return jresult;
71455 }
71456
71457
71458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
71459   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71460   float arg2 ;
71461
71462   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71463   arg2 = (float)jarg2;
71464   if (arg1) (arg1)->max = arg2;
71465 }
71466
71467
71468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
71469   float jresult ;
71470   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71471   float result;
71472
71473   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71474   result = (float) ((arg1)->max);
71475   jresult = result;
71476   return jresult;
71477 }
71478
71479
71480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
71481   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71482   bool arg2 ;
71483
71484   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71485   arg2 = jarg2 ? true : false;
71486   if (arg1) (arg1)->enabled = arg2;
71487 }
71488
71489
71490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
71491   unsigned int jresult ;
71492   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71493   bool result;
71494
71495   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71496   result = (bool) ((arg1)->enabled);
71497   jresult = result;
71498   return jresult;
71499 }
71500
71501
71502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
71503   float jresult ;
71504   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71505   float arg2 ;
71506   float arg3 ;
71507   float arg4 ;
71508   float result;
71509
71510   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71511   arg2 = (float)jarg2;
71512   arg3 = (float)jarg3;
71513   arg4 = (float)jarg4;
71514   {
71515     try {
71516       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
71517     } catch (std::out_of_range& e) {
71518       {
71519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71520       };
71521     } catch (std::exception& e) {
71522       {
71523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71524       };
71525     } catch (...) {
71526       {
71527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71528       };
71529     }
71530   }
71531   jresult = result;
71532   return jresult;
71533 }
71534
71535
71536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
71537   float jresult ;
71538   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71539   float arg2 ;
71540   float arg3 ;
71541   float result;
71542
71543   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71544   arg2 = (float)jarg2;
71545   arg3 = (float)jarg3;
71546   {
71547     try {
71548       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
71549     } catch (std::out_of_range& e) {
71550       {
71551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71552       };
71553     } catch (std::exception& e) {
71554       {
71555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71556       };
71557     } catch (...) {
71558       {
71559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71560       };
71561     }
71562   }
71563   jresult = result;
71564   return jresult;
71565 }
71566
71567
71568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
71569   float jresult ;
71570   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71571   float arg2 ;
71572   float result;
71573
71574   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71575   arg2 = (float)jarg2;
71576   {
71577     try {
71578       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
71579     } catch (std::out_of_range& e) {
71580       {
71581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71582       };
71583     } catch (std::exception& e) {
71584       {
71585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71586       };
71587     } catch (...) {
71588       {
71589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71590       };
71591     }
71592   }
71593   jresult = result;
71594   return jresult;
71595 }
71596
71597
71598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
71599   float jresult ;
71600   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71601   float arg2 ;
71602   float arg3 ;
71603   float arg4 ;
71604   Dali::Toolkit::ClampState *arg5 = 0 ;
71605   float result;
71606
71607   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71608   arg2 = (float)jarg2;
71609   arg3 = (float)jarg3;
71610   arg4 = (float)jarg4;
71611   arg5 = (Dali::Toolkit::ClampState *)jarg5;
71612   if (!arg5) {
71613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
71614     return 0;
71615   }
71616   {
71617     try {
71618       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
71619     } catch (std::out_of_range& e) {
71620       {
71621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71622       };
71623     } catch (std::exception& e) {
71624       {
71625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71626       };
71627     } catch (...) {
71628       {
71629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71630       };
71631     }
71632   }
71633   jresult = result;
71634   return jresult;
71635 }
71636
71637
71638 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
71639   float jresult ;
71640   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71641   float result;
71642
71643   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71644   {
71645     try {
71646       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
71647     } catch (std::out_of_range& e) {
71648       {
71649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71650       };
71651     } catch (std::exception& e) {
71652       {
71653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71654       };
71655     } catch (...) {
71656       {
71657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71658       };
71659     }
71660   }
71661   jresult = result;
71662   return jresult;
71663 }
71664
71665
71666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
71667   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
71668
71669   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
71670   {
71671     try {
71672       delete arg1;
71673     } catch (std::out_of_range& e) {
71674       {
71675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71676       };
71677     } catch (std::exception& e) {
71678       {
71679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71680       };
71681     } catch (...) {
71682       {
71683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71684       };
71685     }
71686   }
71687 }
71688
71689
71690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
71691   float jresult ;
71692   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71693   float arg2 ;
71694   float arg3 ;
71695   float result;
71696
71697   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71698   arg2 = (float)jarg2;
71699   arg3 = (float)jarg3;
71700   {
71701     try {
71702       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
71703     } catch (std::out_of_range& e) {
71704       {
71705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71706       };
71707     } catch (std::exception& e) {
71708       {
71709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71710       };
71711     } catch (...) {
71712       {
71713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71714       };
71715     }
71716   }
71717   jresult = result;
71718   return jresult;
71719 }
71720
71721
71722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
71723   float jresult ;
71724   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71725   float arg2 ;
71726   float result;
71727
71728   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71729   arg2 = (float)jarg2;
71730   {
71731     try {
71732       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
71733     } catch (std::out_of_range& e) {
71734       {
71735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71736       };
71737     } catch (std::exception& e) {
71738       {
71739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71740       };
71741     } catch (...) {
71742       {
71743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71744       };
71745     }
71746   }
71747   jresult = result;
71748   return jresult;
71749 }
71750
71751
71752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
71753   float jresult ;
71754   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71755   unsigned int arg2 ;
71756   unsigned int *arg3 = 0 ;
71757   bool arg4 ;
71758   float result;
71759
71760   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71761   arg2 = (unsigned int)jarg2;
71762   arg3 = (unsigned int *)jarg3;
71763   arg4 = jarg4 ? true : false;
71764   {
71765     try {
71766       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
71767     } catch (std::out_of_range& e) {
71768       {
71769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71770       };
71771     } catch (std::exception& e) {
71772       {
71773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71774       };
71775     } catch (...) {
71776       {
71777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71778       };
71779     }
71780   }
71781   jresult = result;
71782   return jresult;
71783 }
71784
71785
71786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
71787   unsigned int jresult ;
71788   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71789   float arg2 ;
71790   bool arg3 ;
71791   unsigned int result;
71792
71793   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71794   arg2 = (float)jarg2;
71795   arg3 = jarg3 ? true : false;
71796   {
71797     try {
71798       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
71799     } catch (std::out_of_range& e) {
71800       {
71801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71802       };
71803     } catch (std::exception& e) {
71804       {
71805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71806       };
71807     } catch (...) {
71808       {
71809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71810       };
71811     }
71812   }
71813   jresult = result;
71814   return jresult;
71815 }
71816
71817
71818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
71819   unsigned int jresult ;
71820   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71821   unsigned int result;
71822
71823   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71824   {
71825     try {
71826       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
71827     } catch (std::out_of_range& e) {
71828       {
71829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71830       };
71831     } catch (std::exception& e) {
71832       {
71833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71834       };
71835     } catch (...) {
71836       {
71837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71838       };
71839     }
71840   }
71841   jresult = result;
71842   return jresult;
71843 }
71844
71845
71846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
71847   int jresult ;
71848   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71849   Dali::Toolkit::Ruler::RulerType result;
71850
71851   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71852   {
71853     try {
71854       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
71855     } catch (std::out_of_range& e) {
71856       {
71857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71858       };
71859     } catch (std::exception& e) {
71860       {
71861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71862       };
71863     } catch (...) {
71864       {
71865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71866       };
71867     }
71868   }
71869   jresult = (int)result;
71870   return jresult;
71871 }
71872
71873
71874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
71875   unsigned int jresult ;
71876   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71877   bool result;
71878
71879   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71880   {
71881     try {
71882       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
71883     } catch (std::out_of_range& e) {
71884       {
71885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71886       };
71887     } catch (std::exception& e) {
71888       {
71889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71890       };
71891     } catch (...) {
71892       {
71893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71894       };
71895     }
71896   }
71897   jresult = result;
71898   return jresult;
71899 }
71900
71901
71902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
71903   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71904
71905   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71906   {
71907     try {
71908       (arg1)->Enable();
71909     } catch (std::out_of_range& e) {
71910       {
71911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71912       };
71913     } catch (std::exception& e) {
71914       {
71915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71916       };
71917     } catch (...) {
71918       {
71919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71920       };
71921     }
71922   }
71923 }
71924
71925
71926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
71927   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71928
71929   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71930   {
71931     try {
71932       (arg1)->Disable();
71933     } catch (std::out_of_range& e) {
71934       {
71935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71936       };
71937     } catch (std::exception& e) {
71938       {
71939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71940       };
71941     } catch (...) {
71942       {
71943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71944       };
71945     }
71946   }
71947 }
71948
71949
71950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
71951   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71952   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
71953   Dali::Toolkit::RulerDomain *argp2 ;
71954
71955   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71956   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
71957   if (!argp2) {
71958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
71959     return ;
71960   }
71961   arg2 = *argp2;
71962   {
71963     try {
71964       (arg1)->SetDomain(arg2);
71965     } catch (std::out_of_range& e) {
71966       {
71967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71968       };
71969     } catch (std::exception& e) {
71970       {
71971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71972       };
71973     } catch (...) {
71974       {
71975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71976       };
71977     }
71978   }
71979 }
71980
71981
71982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
71983   void * jresult ;
71984   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
71985   Dali::Toolkit::RulerDomain *result = 0 ;
71986
71987   arg1 = (Dali::Toolkit::Ruler *)jarg1;
71988   {
71989     try {
71990       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
71991     } catch (std::out_of_range& e) {
71992       {
71993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71994       };
71995     } catch (std::exception& e) {
71996       {
71997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71998       };
71999     } catch (...) {
72000       {
72001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72002       };
72003     }
72004   }
72005   jresult = (void *)result;
72006   return jresult;
72007 }
72008
72009
72010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
72011   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72012
72013   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72014   {
72015     try {
72016       (arg1)->DisableDomain();
72017     } catch (std::out_of_range& e) {
72018       {
72019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72020       };
72021     } catch (std::exception& e) {
72022       {
72023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72024       };
72025     } catch (...) {
72026       {
72027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72028       };
72029     }
72030   }
72031 }
72032
72033
72034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72035   float jresult ;
72036   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72037   float arg2 ;
72038   float arg3 ;
72039   float arg4 ;
72040   float result;
72041
72042   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72043   arg2 = (float)jarg2;
72044   arg3 = (float)jarg3;
72045   arg4 = (float)jarg4;
72046   {
72047     try {
72048       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
72049     } catch (std::out_of_range& e) {
72050       {
72051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72052       };
72053     } catch (std::exception& e) {
72054       {
72055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72056       };
72057     } catch (...) {
72058       {
72059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72060       };
72061     }
72062   }
72063   jresult = result;
72064   return jresult;
72065 }
72066
72067
72068 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72069   float jresult ;
72070   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72071   float arg2 ;
72072   float arg3 ;
72073   float result;
72074
72075   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72076   arg2 = (float)jarg2;
72077   arg3 = (float)jarg3;
72078   {
72079     try {
72080       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
72081     } catch (std::out_of_range& e) {
72082       {
72083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72084       };
72085     } catch (std::exception& e) {
72086       {
72087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72088       };
72089     } catch (...) {
72090       {
72091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72092       };
72093     }
72094   }
72095   jresult = result;
72096   return jresult;
72097 }
72098
72099
72100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
72101   float jresult ;
72102   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72103   float arg2 ;
72104   float result;
72105
72106   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72107   arg2 = (float)jarg2;
72108   {
72109     try {
72110       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
72111     } catch (std::out_of_range& e) {
72112       {
72113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72114       };
72115     } catch (std::exception& e) {
72116       {
72117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72118       };
72119     } catch (...) {
72120       {
72121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72122       };
72123     }
72124   }
72125   jresult = result;
72126   return jresult;
72127 }
72128
72129
72130 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72131   float jresult ;
72132   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72133   float arg2 ;
72134   float arg3 ;
72135   float arg4 ;
72136   Dali::Toolkit::ClampState *arg5 = 0 ;
72137   float result;
72138
72139   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72140   arg2 = (float)jarg2;
72141   arg3 = (float)jarg3;
72142   arg4 = (float)jarg4;
72143   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72144   if (!arg5) {
72145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72146     return 0;
72147   }
72148   {
72149     try {
72150       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72151     } catch (std::out_of_range& e) {
72152       {
72153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72154       };
72155     } catch (std::exception& e) {
72156       {
72157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72158       };
72159     } catch (...) {
72160       {
72161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72162       };
72163     }
72164   }
72165   jresult = result;
72166   return jresult;
72167 }
72168
72169
72170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
72171   float jresult ;
72172   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72173   float arg2 ;
72174   float arg3 ;
72175   float arg4 ;
72176   float arg5 ;
72177   float result;
72178
72179   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72180   arg2 = (float)jarg2;
72181   arg3 = (float)jarg3;
72182   arg4 = (float)jarg4;
72183   arg5 = (float)jarg5;
72184   {
72185     try {
72186       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
72187     } catch (std::out_of_range& e) {
72188       {
72189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72190       };
72191     } catch (std::exception& e) {
72192       {
72193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72194       };
72195     } catch (...) {
72196       {
72197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72198       };
72199     }
72200   }
72201   jresult = result;
72202   return jresult;
72203 }
72204
72205
72206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
72207   float jresult ;
72208   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72209   float arg2 ;
72210   float arg3 ;
72211   float arg4 ;
72212   float result;
72213
72214   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72215   arg2 = (float)jarg2;
72216   arg3 = (float)jarg3;
72217   arg4 = (float)jarg4;
72218   {
72219     try {
72220       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
72221     } catch (std::out_of_range& e) {
72222       {
72223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72224       };
72225     } catch (std::exception& e) {
72226       {
72227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72228       };
72229     } catch (...) {
72230       {
72231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72232       };
72233     }
72234   }
72235   jresult = result;
72236   return jresult;
72237 }
72238
72239
72240 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
72241   float jresult ;
72242   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72243   float arg2 ;
72244   float arg3 ;
72245   float result;
72246
72247   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72248   arg2 = (float)jarg2;
72249   arg3 = (float)jarg3;
72250   {
72251     try {
72252       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
72253     } catch (std::out_of_range& e) {
72254       {
72255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72256       };
72257     } catch (std::exception& e) {
72258       {
72259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72260       };
72261     } catch (...) {
72262       {
72263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72264       };
72265     }
72266   }
72267   jresult = result;
72268   return jresult;
72269 }
72270
72271
72272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
72273   float jresult ;
72274   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72275   float arg2 ;
72276   float result;
72277
72278   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72279   arg2 = (float)jarg2;
72280   {
72281     try {
72282       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
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 = result;
72298   return jresult;
72299 }
72300
72301
72302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
72303   float jresult ;
72304   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72305   float arg2 ;
72306   float arg3 ;
72307   float arg4 ;
72308   float arg5 ;
72309   Dali::Toolkit::ClampState *arg6 = 0 ;
72310   float result;
72311
72312   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72313   arg2 = (float)jarg2;
72314   arg3 = (float)jarg3;
72315   arg4 = (float)jarg4;
72316   arg5 = (float)jarg5;
72317   arg6 = (Dali::Toolkit::ClampState *)jarg6;
72318   if (!arg6) {
72319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72320     return 0;
72321   }
72322   {
72323     try {
72324       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
72325     } catch (std::out_of_range& e) {
72326       {
72327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72328       };
72329     } catch (std::exception& e) {
72330       {
72331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72332       };
72333     } catch (...) {
72334       {
72335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72336       };
72337     }
72338   }
72339   jresult = result;
72340   return jresult;
72341 }
72342
72343
72344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
72345   void * jresult ;
72346   Dali::Toolkit::DefaultRuler *result = 0 ;
72347
72348   {
72349     try {
72350       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
72351     } catch (std::out_of_range& e) {
72352       {
72353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72354       };
72355     } catch (std::exception& e) {
72356       {
72357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72358       };
72359     } catch (...) {
72360       {
72361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72362       };
72363     }
72364   }
72365   jresult = (void *)result;
72366   return jresult;
72367 }
72368
72369
72370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72371   float jresult ;
72372   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72373   float arg2 ;
72374   float arg3 ;
72375   float result;
72376
72377   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72378   arg2 = (float)jarg2;
72379   arg3 = (float)jarg3;
72380   {
72381     try {
72382       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
72383     } catch (std::out_of_range& e) {
72384       {
72385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72386       };
72387     } catch (std::exception& e) {
72388       {
72389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72390       };
72391     } catch (...) {
72392       {
72393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72394       };
72395     }
72396   }
72397   jresult = result;
72398   return jresult;
72399 }
72400
72401
72402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72403   float jresult ;
72404   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72405   unsigned int arg2 ;
72406   unsigned int *arg3 = 0 ;
72407   bool arg4 ;
72408   float result;
72409
72410   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72411   arg2 = (unsigned int)jarg2;
72412   arg3 = (unsigned int *)jarg3;
72413   arg4 = jarg4 ? true : false;
72414   {
72415     try {
72416       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72417     } catch (std::out_of_range& e) {
72418       {
72419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72420       };
72421     } catch (std::exception& e) {
72422       {
72423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72424       };
72425     } catch (...) {
72426       {
72427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72428       };
72429     }
72430   }
72431   jresult = result;
72432   return jresult;
72433 }
72434
72435
72436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72437   unsigned int jresult ;
72438   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72439   float arg2 ;
72440   bool arg3 ;
72441   unsigned int result;
72442
72443   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72444   arg2 = (float)jarg2;
72445   arg3 = jarg3 ? true : false;
72446   {
72447     try {
72448       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72449     } catch (std::out_of_range& e) {
72450       {
72451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72452       };
72453     } catch (std::exception& e) {
72454       {
72455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72456       };
72457     } catch (...) {
72458       {
72459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72460       };
72461     }
72462   }
72463   jresult = result;
72464   return jresult;
72465 }
72466
72467
72468 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
72469   unsigned int jresult ;
72470   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72471   unsigned int result;
72472
72473   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72474   {
72475     try {
72476       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
72477     } catch (std::out_of_range& e) {
72478       {
72479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72480       };
72481     } catch (std::exception& e) {
72482       {
72483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72484       };
72485     } catch (...) {
72486       {
72487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72488       };
72489     }
72490   }
72491   jresult = result;
72492   return jresult;
72493 }
72494
72495
72496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
72497   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
72498
72499   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
72500   {
72501     try {
72502       delete arg1;
72503     } catch (std::out_of_range& e) {
72504       {
72505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72506       };
72507     } catch (std::exception& e) {
72508       {
72509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72510       };
72511     } catch (...) {
72512       {
72513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72514       };
72515     }
72516   }
72517 }
72518
72519
72520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
72521   void * jresult ;
72522   float arg1 ;
72523   Dali::Toolkit::FixedRuler *result = 0 ;
72524
72525   arg1 = (float)jarg1;
72526   {
72527     try {
72528       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
72529     } catch (std::out_of_range& e) {
72530       {
72531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72532       };
72533     } catch (std::exception& e) {
72534       {
72535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72536       };
72537     } catch (...) {
72538       {
72539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72540       };
72541     }
72542   }
72543   jresult = (void *)result;
72544   return jresult;
72545 }
72546
72547
72548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
72549   void * jresult ;
72550   Dali::Toolkit::FixedRuler *result = 0 ;
72551
72552   {
72553     try {
72554       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
72555     } catch (std::out_of_range& e) {
72556       {
72557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72558       };
72559     } catch (std::exception& e) {
72560       {
72561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72562       };
72563     } catch (...) {
72564       {
72565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72566       };
72567     }
72568   }
72569   jresult = (void *)result;
72570   return jresult;
72571 }
72572
72573
72574 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
72575   float jresult ;
72576   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72577   float arg2 ;
72578   float arg3 ;
72579   float result;
72580
72581   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72582   arg2 = (float)jarg2;
72583   arg3 = (float)jarg3;
72584   {
72585     try {
72586       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
72587     } catch (std::out_of_range& e) {
72588       {
72589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72590       };
72591     } catch (std::exception& e) {
72592       {
72593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72594       };
72595     } catch (...) {
72596       {
72597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72598       };
72599     }
72600   }
72601   jresult = result;
72602   return jresult;
72603 }
72604
72605
72606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72607   float jresult ;
72608   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72609   unsigned int arg2 ;
72610   unsigned int *arg3 = 0 ;
72611   bool arg4 ;
72612   float result;
72613
72614   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72615   arg2 = (unsigned int)jarg2;
72616   arg3 = (unsigned int *)jarg3;
72617   arg4 = jarg4 ? true : false;
72618   {
72619     try {
72620       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72621     } catch (std::out_of_range& e) {
72622       {
72623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72624       };
72625     } catch (std::exception& e) {
72626       {
72627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72628       };
72629     } catch (...) {
72630       {
72631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72632       };
72633     }
72634   }
72635   jresult = result;
72636   return jresult;
72637 }
72638
72639
72640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72641   unsigned int jresult ;
72642   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72643   float arg2 ;
72644   bool arg3 ;
72645   unsigned int result;
72646
72647   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72648   arg2 = (float)jarg2;
72649   arg3 = jarg3 ? true : false;
72650   {
72651     try {
72652       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
72653     } catch (std::out_of_range& e) {
72654       {
72655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72656       };
72657     } catch (std::exception& e) {
72658       {
72659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72660       };
72661     } catch (...) {
72662       {
72663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72664       };
72665     }
72666   }
72667   jresult = result;
72668   return jresult;
72669 }
72670
72671
72672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
72673   unsigned int jresult ;
72674   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72675   unsigned int result;
72676
72677   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72678   {
72679     try {
72680       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
72681     } catch (std::out_of_range& e) {
72682       {
72683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72684       };
72685     } catch (std::exception& e) {
72686       {
72687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72688       };
72689     } catch (...) {
72690       {
72691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72692       };
72693     }
72694   }
72695   jresult = result;
72696   return jresult;
72697 }
72698
72699
72700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
72701   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
72702
72703   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
72704   {
72705     try {
72706       delete arg1;
72707     } catch (std::out_of_range& e) {
72708       {
72709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72710       };
72711     } catch (std::exception& e) {
72712       {
72713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72714       };
72715     } catch (...) {
72716       {
72717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72718       };
72719     }
72720   }
72721 }
72722
72723
72724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
72725   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72726   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72727
72728   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72729   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72730   if (arg1) (arg1)->scale = *arg2;
72731 }
72732
72733
72734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
72735   void * jresult ;
72736   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72737   Dali::Toolkit::ClampState2D *result = 0 ;
72738
72739   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72740   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
72741   jresult = (void *)result;
72742   return jresult;
72743 }
72744
72745
72746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
72747   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72748   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
72749
72750   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72751   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
72752   if (arg1) (arg1)->position = *arg2;
72753 }
72754
72755
72756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
72757   void * jresult ;
72758   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72759   Dali::Toolkit::ClampState2D *result = 0 ;
72760
72761   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72762   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
72763   jresult = (void *)result;
72764   return jresult;
72765 }
72766
72767
72768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
72769   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72770   Dali::Toolkit::ClampState arg2 ;
72771
72772   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72773   arg2 = (Dali::Toolkit::ClampState)jarg2;
72774   if (arg1) (arg1)->rotation = arg2;
72775 }
72776
72777
72778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
72779   int jresult ;
72780   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72781   Dali::Toolkit::ClampState result;
72782
72783   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72784   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
72785   jresult = (int)result;
72786   return jresult;
72787 }
72788
72789
72790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
72791   void * jresult ;
72792   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
72793
72794   {
72795     try {
72796       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
72797     } catch (std::out_of_range& e) {
72798       {
72799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72800       };
72801     } catch (std::exception& e) {
72802       {
72803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72804       };
72805     } catch (...) {
72806       {
72807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72808       };
72809     }
72810   }
72811   jresult = (void *)result;
72812   return jresult;
72813 }
72814
72815
72816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
72817   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
72818
72819   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
72820   {
72821     try {
72822       delete arg1;
72823     } catch (std::out_of_range& e) {
72824       {
72825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72826       };
72827     } catch (std::exception& e) {
72828       {
72829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72830       };
72831     } catch (...) {
72832       {
72833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72834       };
72835     }
72836   }
72837 }
72838
72839
72840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
72841   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72842   Dali::Toolkit::SnapType arg2 ;
72843
72844   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72845   arg2 = (Dali::Toolkit::SnapType)jarg2;
72846   if (arg1) (arg1)->type = arg2;
72847 }
72848
72849
72850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
72851   int jresult ;
72852   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72853   Dali::Toolkit::SnapType result;
72854
72855   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72856   result = (Dali::Toolkit::SnapType) ((arg1)->type);
72857   jresult = (int)result;
72858   return jresult;
72859 }
72860
72861
72862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
72863   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72864   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
72865
72866   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72867   arg2 = (Dali::Vector2 *)jarg2;
72868   if (arg1) (arg1)->position = *arg2;
72869 }
72870
72871
72872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
72873   void * jresult ;
72874   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72875   Dali::Vector2 *result = 0 ;
72876
72877   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72878   result = (Dali::Vector2 *)& ((arg1)->position);
72879   jresult = (void *)result;
72880   return jresult;
72881 }
72882
72883
72884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
72885   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72886   float arg2 ;
72887
72888   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72889   arg2 = (float)jarg2;
72890   if (arg1) (arg1)->duration = arg2;
72891 }
72892
72893
72894 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
72895   float jresult ;
72896   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72897   float result;
72898
72899   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72900   result = (float) ((arg1)->duration);
72901   jresult = result;
72902   return jresult;
72903 }
72904
72905
72906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
72907   void * jresult ;
72908   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
72909
72910   {
72911     try {
72912       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
72913     } catch (std::out_of_range& e) {
72914       {
72915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72916       };
72917     } catch (std::exception& e) {
72918       {
72919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72920       };
72921     } catch (...) {
72922       {
72923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72924       };
72925     }
72926   }
72927   jresult = (void *)result;
72928   return jresult;
72929 }
72930
72931
72932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
72933   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
72934
72935   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
72936   {
72937     try {
72938       delete arg1;
72939     } catch (std::out_of_range& e) {
72940       {
72941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72942       };
72943     } catch (std::exception& e) {
72944       {
72945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72946       };
72947     } catch (...) {
72948       {
72949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72950       };
72951     }
72952   }
72953 }
72954
72955
72956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
72957   int jresult ;
72958   int result;
72959
72960   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
72961   jresult = (int)result;
72962   return jresult;
72963 }
72964
72965
72966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
72967   int jresult ;
72968   int result;
72969
72970   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
72971   jresult = (int)result;
72972   return jresult;
72973 }
72974
72975
72976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
72977   int jresult ;
72978   int result;
72979
72980   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
72981   jresult = (int)result;
72982   return jresult;
72983 }
72984
72985
72986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
72987   int jresult ;
72988   int result;
72989
72990   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
72991   jresult = (int)result;
72992   return jresult;
72993 }
72994
72995
72996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
72997   int jresult ;
72998   int result;
72999
73000   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
73001   jresult = (int)result;
73002   return jresult;
73003 }
73004
73005
73006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
73007   int jresult ;
73008   int result;
73009
73010   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
73011   jresult = (int)result;
73012   return jresult;
73013 }
73014
73015
73016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
73017   int jresult ;
73018   int result;
73019
73020   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
73021   jresult = (int)result;
73022   return jresult;
73023 }
73024
73025
73026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
73027   int jresult ;
73028   int result;
73029
73030   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
73031   jresult = (int)result;
73032   return jresult;
73033 }
73034
73035
73036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
73037   int jresult ;
73038   int result;
73039
73040   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
73041   jresult = (int)result;
73042   return jresult;
73043 }
73044
73045
73046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
73047   int jresult ;
73048   int result;
73049
73050   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
73051   jresult = (int)result;
73052   return jresult;
73053 }
73054
73055
73056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
73057   int jresult ;
73058   int result;
73059
73060   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
73061   jresult = (int)result;
73062   return jresult;
73063 }
73064
73065
73066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
73067   int jresult ;
73068   int result;
73069
73070   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
73071   jresult = (int)result;
73072   return jresult;
73073 }
73074
73075
73076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
73077   int jresult ;
73078   int result;
73079
73080   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
73081   jresult = (int)result;
73082   return jresult;
73083 }
73084
73085
73086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
73087   int jresult ;
73088   int result;
73089
73090   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
73091   jresult = (int)result;
73092   return jresult;
73093 }
73094
73095
73096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
73097   int jresult ;
73098   int result;
73099
73100   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
73101   jresult = (int)result;
73102   return jresult;
73103 }
73104
73105
73106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
73107   int jresult ;
73108   int result;
73109
73110   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
73111   jresult = (int)result;
73112   return jresult;
73113 }
73114
73115
73116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
73117   int jresult ;
73118   int result;
73119
73120   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
73121   jresult = (int)result;
73122   return jresult;
73123 }
73124
73125
73126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
73127   int jresult ;
73128   int result;
73129
73130   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
73131   jresult = (int)result;
73132   return jresult;
73133 }
73134
73135
73136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
73137   int jresult ;
73138   int result;
73139
73140   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
73141   jresult = (int)result;
73142   return jresult;
73143 }
73144
73145
73146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
73147   int jresult ;
73148   int result;
73149
73150   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
73151   jresult = (int)result;
73152   return jresult;
73153 }
73154
73155
73156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
73157   int jresult ;
73158   int result;
73159
73160   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
73161   jresult = (int)result;
73162   return jresult;
73163 }
73164
73165
73166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
73167   int jresult ;
73168   int result;
73169
73170   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
73171   jresult = (int)result;
73172   return jresult;
73173 }
73174
73175
73176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
73177   int jresult ;
73178   int result;
73179
73180   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
73181   jresult = (int)result;
73182   return jresult;
73183 }
73184
73185
73186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
73187   int jresult ;
73188   int result;
73189
73190   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
73191   jresult = (int)result;
73192   return jresult;
73193 }
73194
73195
73196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
73197   int jresult ;
73198   int result;
73199
73200   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
73201   jresult = (int)result;
73202   return jresult;
73203 }
73204
73205
73206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
73207   void * jresult ;
73208   Dali::Toolkit::ScrollView::Property *result = 0 ;
73209
73210   {
73211     try {
73212       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
73213     } catch (std::out_of_range& e) {
73214       {
73215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73216       };
73217     } catch (std::exception& e) {
73218       {
73219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73220       };
73221     } catch (...) {
73222       {
73223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73224       };
73225     }
73226   }
73227   jresult = (void *)result;
73228   return jresult;
73229 }
73230
73231
73232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
73233   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
73234
73235   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
73236   {
73237     try {
73238       delete arg1;
73239     } catch (std::out_of_range& e) {
73240       {
73241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73242       };
73243     } catch (std::exception& e) {
73244       {
73245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73246       };
73247     } catch (...) {
73248       {
73249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73250       };
73251     }
73252   }
73253 }
73254
73255
73256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
73257   void * jresult ;
73258   Dali::Toolkit::ScrollView *result = 0 ;
73259
73260   {
73261     try {
73262       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
73263     } catch (std::out_of_range& e) {
73264       {
73265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73266       };
73267     } catch (std::exception& e) {
73268       {
73269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73270       };
73271     } catch (...) {
73272       {
73273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73274       };
73275     }
73276   }
73277   jresult = (void *)result;
73278   return jresult;
73279 }
73280
73281
73282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
73283   void * jresult ;
73284   Dali::Toolkit::ScrollView *arg1 = 0 ;
73285   Dali::Toolkit::ScrollView *result = 0 ;
73286
73287   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73288   if (!arg1) {
73289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73290     return 0;
73291   }
73292   {
73293     try {
73294       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
73295     } catch (std::out_of_range& e) {
73296       {
73297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73298       };
73299     } catch (std::exception& e) {
73300       {
73301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73302       };
73303     } catch (...) {
73304       {
73305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73306       };
73307     }
73308   }
73309   jresult = (void *)result;
73310   return jresult;
73311 }
73312
73313
73314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
73315   void * jresult ;
73316   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73317   Dali::Toolkit::ScrollView *arg2 = 0 ;
73318   Dali::Toolkit::ScrollView *result = 0 ;
73319
73320   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73321   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
73322   if (!arg2) {
73323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
73324     return 0;
73325   }
73326   {
73327     try {
73328       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
73329     } catch (std::out_of_range& e) {
73330       {
73331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73332       };
73333     } catch (std::exception& e) {
73334       {
73335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73336       };
73337     } catch (...) {
73338       {
73339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73340       };
73341     }
73342   }
73343   jresult = (void *)result;
73344   return jresult;
73345 }
73346
73347
73348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
73349   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73350
73351   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73352   {
73353     try {
73354       delete arg1;
73355     } catch (std::out_of_range& e) {
73356       {
73357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73358       };
73359     } catch (std::exception& e) {
73360       {
73361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73362       };
73363     } catch (...) {
73364       {
73365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73366       };
73367     }
73368   }
73369 }
73370
73371
73372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
73373   void * jresult ;
73374   Dali::Toolkit::ScrollView result;
73375
73376   {
73377     try {
73378       result = Dali::Toolkit::ScrollView::New();
73379     } catch (std::out_of_range& e) {
73380       {
73381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73382       };
73383     } catch (std::exception& e) {
73384       {
73385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73386       };
73387     } catch (...) {
73388       {
73389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73390       };
73391     }
73392   }
73393   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73394   return jresult;
73395 }
73396
73397
73398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
73399   void * jresult ;
73400   Dali::BaseHandle arg1 ;
73401   Dali::BaseHandle *argp1 ;
73402   Dali::Toolkit::ScrollView result;
73403
73404   argp1 = (Dali::BaseHandle *)jarg1;
73405   if (!argp1) {
73406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73407     return 0;
73408   }
73409   arg1 = *argp1;
73410   {
73411     try {
73412       result = Dali::Toolkit::ScrollView::DownCast(arg1);
73413     } catch (std::out_of_range& e) {
73414       {
73415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73416       };
73417     } catch (std::exception& e) {
73418       {
73419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73420       };
73421     } catch (...) {
73422       {
73423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73424       };
73425     }
73426   }
73427   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
73428   return jresult;
73429 }
73430
73431
73432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
73433   void * jresult ;
73434   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73435   Dali::AlphaFunction result;
73436
73437   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73438   {
73439     try {
73440       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
73441     } catch (std::out_of_range& e) {
73442       {
73443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73444       };
73445     } catch (std::exception& e) {
73446       {
73447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73448       };
73449     } catch (...) {
73450       {
73451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73452       };
73453     }
73454   }
73455   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73456   return jresult;
73457 }
73458
73459
73460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
73461   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73462   Dali::AlphaFunction arg2 ;
73463   Dali::AlphaFunction *argp2 ;
73464
73465   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73466   argp2 = (Dali::AlphaFunction *)jarg2;
73467   if (!argp2) {
73468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73469     return ;
73470   }
73471   arg2 = *argp2;
73472   {
73473     try {
73474       (arg1)->SetScrollSnapAlphaFunction(arg2);
73475     } catch (std::out_of_range& e) {
73476       {
73477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73478       };
73479     } catch (std::exception& e) {
73480       {
73481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73482       };
73483     } catch (...) {
73484       {
73485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73486       };
73487     }
73488   }
73489 }
73490
73491
73492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
73493   void * jresult ;
73494   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73495   Dali::AlphaFunction result;
73496
73497   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73498   {
73499     try {
73500       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
73501     } catch (std::out_of_range& e) {
73502       {
73503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73504       };
73505     } catch (std::exception& e) {
73506       {
73507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73508       };
73509     } catch (...) {
73510       {
73511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73512       };
73513     }
73514   }
73515   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
73516   return jresult;
73517 }
73518
73519
73520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
73521   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73522   Dali::AlphaFunction arg2 ;
73523   Dali::AlphaFunction *argp2 ;
73524
73525   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73526   argp2 = (Dali::AlphaFunction *)jarg2;
73527   if (!argp2) {
73528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73529     return ;
73530   }
73531   arg2 = *argp2;
73532   {
73533     try {
73534       (arg1)->SetScrollFlickAlphaFunction(arg2);
73535     } catch (std::out_of_range& e) {
73536       {
73537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73538       };
73539     } catch (std::exception& e) {
73540       {
73541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73542       };
73543     } catch (...) {
73544       {
73545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73546       };
73547     }
73548   }
73549 }
73550
73551
73552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
73553   float jresult ;
73554   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73555   float result;
73556
73557   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73558   {
73559     try {
73560       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
73561     } catch (std::out_of_range& e) {
73562       {
73563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73564       };
73565     } catch (std::exception& e) {
73566       {
73567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73568       };
73569     } catch (...) {
73570       {
73571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73572       };
73573     }
73574   }
73575   jresult = result;
73576   return jresult;
73577 }
73578
73579
73580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
73581   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73582   float arg2 ;
73583
73584   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73585   arg2 = (float)jarg2;
73586   {
73587     try {
73588       (arg1)->SetScrollSnapDuration(arg2);
73589     } catch (std::out_of_range& e) {
73590       {
73591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73592       };
73593     } catch (std::exception& e) {
73594       {
73595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73596       };
73597     } catch (...) {
73598       {
73599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73600       };
73601     }
73602   }
73603 }
73604
73605
73606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
73607   float jresult ;
73608   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73609   float result;
73610
73611   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73612   {
73613     try {
73614       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
73615     } catch (std::out_of_range& e) {
73616       {
73617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73618       };
73619     } catch (std::exception& e) {
73620       {
73621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73622       };
73623     } catch (...) {
73624       {
73625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73626       };
73627     }
73628   }
73629   jresult = result;
73630   return jresult;
73631 }
73632
73633
73634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
73635   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73636   float arg2 ;
73637
73638   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73639   arg2 = (float)jarg2;
73640   {
73641     try {
73642       (arg1)->SetScrollFlickDuration(arg2);
73643     } catch (std::out_of_range& e) {
73644       {
73645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73646       };
73647     } catch (std::exception& e) {
73648       {
73649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73650       };
73651     } catch (...) {
73652       {
73653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73654       };
73655     }
73656   }
73657 }
73658
73659
73660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
73661   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73662   Dali::Toolkit::RulerPtr arg2 ;
73663   Dali::Toolkit::RulerPtr *argp2 ;
73664
73665   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73666   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73667   if (!argp2) {
73668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73669     return ;
73670   }
73671   arg2 = *argp2;
73672   {
73673     try {
73674       (arg1)->SetRulerX(arg2);
73675     } catch (std::out_of_range& e) {
73676       {
73677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73678       };
73679     } catch (std::exception& e) {
73680       {
73681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73682       };
73683     } catch (...) {
73684       {
73685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73686       };
73687     }
73688   }
73689 }
73690
73691
73692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
73693   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73694   Dali::Toolkit::RulerPtr arg2 ;
73695   Dali::Toolkit::RulerPtr *argp2 ;
73696
73697   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73698   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
73699   if (!argp2) {
73700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
73701     return ;
73702   }
73703   arg2 = *argp2;
73704   {
73705     try {
73706       (arg1)->SetRulerY(arg2);
73707     } catch (std::out_of_range& e) {
73708       {
73709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73710       };
73711     } catch (std::exception& e) {
73712       {
73713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73714       };
73715     } catch (...) {
73716       {
73717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73718       };
73719     }
73720   }
73721 }
73722
73723
73724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(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)->SetScrollSensitive(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 void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
73751   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73752   float arg2 ;
73753   float arg3 ;
73754
73755   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73756   arg2 = (float)jarg2;
73757   arg3 = (float)jarg3;
73758   {
73759     try {
73760       (arg1)->SetMaxOvershoot(arg2,arg3);
73761     } catch (std::out_of_range& e) {
73762       {
73763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73764       };
73765     } catch (std::exception& e) {
73766       {
73767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73768       };
73769     } catch (...) {
73770       {
73771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73772       };
73773     }
73774   }
73775 }
73776
73777
73778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
73779   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73780   Dali::AlphaFunction arg2 ;
73781   Dali::AlphaFunction *argp2 ;
73782
73783   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73784   argp2 = (Dali::AlphaFunction *)jarg2;
73785   if (!argp2) {
73786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
73787     return ;
73788   }
73789   arg2 = *argp2;
73790   {
73791     try {
73792       (arg1)->SetSnapOvershootAlphaFunction(arg2);
73793     } catch (std::out_of_range& e) {
73794       {
73795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73796       };
73797     } catch (std::exception& e) {
73798       {
73799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73800       };
73801     } catch (...) {
73802       {
73803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73804       };
73805     }
73806   }
73807 }
73808
73809
73810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
73811   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73812   float arg2 ;
73813
73814   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73815   arg2 = (float)jarg2;
73816   {
73817     try {
73818       (arg1)->SetSnapOvershootDuration(arg2);
73819     } catch (std::out_of_range& e) {
73820       {
73821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73822       };
73823     } catch (std::exception& e) {
73824       {
73825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73826       };
73827     } catch (...) {
73828       {
73829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73830       };
73831     }
73832   }
73833 }
73834
73835
73836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
73837   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73838   bool arg2 ;
73839
73840   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73841   arg2 = jarg2 ? true : false;
73842   {
73843     try {
73844       (arg1)->SetActorAutoSnap(arg2);
73845     } catch (std::out_of_range& e) {
73846       {
73847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73848       };
73849     } catch (std::exception& e) {
73850       {
73851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73852       };
73853     } catch (...) {
73854       {
73855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73856       };
73857     }
73858   }
73859 }
73860
73861
73862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
73863   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73864   bool arg2 ;
73865
73866   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73867   arg2 = jarg2 ? true : false;
73868   {
73869     try {
73870       (arg1)->SetWrapMode(arg2);
73871     } catch (std::out_of_range& e) {
73872       {
73873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73874       };
73875     } catch (std::exception& e) {
73876       {
73877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73878       };
73879     } catch (...) {
73880       {
73881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73882       };
73883     }
73884   }
73885 }
73886
73887
73888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
73889   int jresult ;
73890   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73891   int result;
73892
73893   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73894   {
73895     try {
73896       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
73897     } catch (std::out_of_range& e) {
73898       {
73899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73900       };
73901     } catch (std::exception& e) {
73902       {
73903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73904       };
73905     } catch (...) {
73906       {
73907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73908       };
73909     }
73910   }
73911   jresult = result;
73912   return jresult;
73913 }
73914
73915
73916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
73917   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73918   int arg2 ;
73919
73920   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73921   arg2 = (int)jarg2;
73922   {
73923     try {
73924       (arg1)->SetScrollUpdateDistance(arg2);
73925     } catch (std::out_of_range& e) {
73926       {
73927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73928       };
73929     } catch (std::exception& e) {
73930       {
73931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73932       };
73933     } catch (...) {
73934       {
73935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73936       };
73937     }
73938   }
73939 }
73940
73941
73942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
73943   unsigned int jresult ;
73944   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73945   bool result;
73946
73947   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73948   {
73949     try {
73950       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
73951     } catch (std::out_of_range& e) {
73952       {
73953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73954       };
73955     } catch (std::exception& e) {
73956       {
73957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73958       };
73959     } catch (...) {
73960       {
73961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73962       };
73963     }
73964   }
73965   jresult = result;
73966   return jresult;
73967 }
73968
73969
73970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
73971   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73972   bool arg2 ;
73973
73974   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
73975   arg2 = jarg2 ? true : false;
73976   {
73977     try {
73978       (arg1)->SetAxisAutoLock(arg2);
73979     } catch (std::out_of_range& e) {
73980       {
73981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73982       };
73983     } catch (std::exception& e) {
73984       {
73985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73986       };
73987     } catch (...) {
73988       {
73989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73990       };
73991     }
73992   }
73993 }
73994
73995
73996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
73997   float jresult ;
73998   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
73999   float result;
74000
74001   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74002   {
74003     try {
74004       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
74005     } catch (std::out_of_range& e) {
74006       {
74007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74008       };
74009     } catch (std::exception& e) {
74010       {
74011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74012       };
74013     } catch (...) {
74014       {
74015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74016       };
74017     }
74018   }
74019   jresult = result;
74020   return jresult;
74021 }
74022
74023
74024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
74025   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74026   float arg2 ;
74027
74028   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74029   arg2 = (float)jarg2;
74030   {
74031     try {
74032       (arg1)->SetAxisAutoLockGradient(arg2);
74033     } catch (std::out_of_range& e) {
74034       {
74035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74036       };
74037     } catch (std::exception& e) {
74038       {
74039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74040       };
74041     } catch (...) {
74042       {
74043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74044       };
74045     }
74046   }
74047 }
74048
74049
74050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
74051   float jresult ;
74052   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74053   float result;
74054
74055   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74056   {
74057     try {
74058       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
74059     } catch (std::out_of_range& e) {
74060       {
74061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74062       };
74063     } catch (std::exception& e) {
74064       {
74065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74066       };
74067     } catch (...) {
74068       {
74069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74070       };
74071     }
74072   }
74073   jresult = result;
74074   return jresult;
74075 }
74076
74077
74078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
74079   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74080   float arg2 ;
74081
74082   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74083   arg2 = (float)jarg2;
74084   {
74085     try {
74086       (arg1)->SetFrictionCoefficient(arg2);
74087     } catch (std::out_of_range& e) {
74088       {
74089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74090       };
74091     } catch (std::exception& e) {
74092       {
74093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74094       };
74095     } catch (...) {
74096       {
74097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74098       };
74099     }
74100   }
74101 }
74102
74103
74104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
74105   float jresult ;
74106   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74107   float result;
74108
74109   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74110   {
74111     try {
74112       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
74113     } catch (std::out_of_range& e) {
74114       {
74115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74116       };
74117     } catch (std::exception& e) {
74118       {
74119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74120       };
74121     } catch (...) {
74122       {
74123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74124       };
74125     }
74126   }
74127   jresult = result;
74128   return jresult;
74129 }
74130
74131
74132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
74133   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74134   float arg2 ;
74135
74136   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74137   arg2 = (float)jarg2;
74138   {
74139     try {
74140       (arg1)->SetFlickSpeedCoefficient(arg2);
74141     } catch (std::out_of_range& e) {
74142       {
74143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74144       };
74145     } catch (std::exception& e) {
74146       {
74147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74148       };
74149     } catch (...) {
74150       {
74151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74152       };
74153     }
74154   }
74155 }
74156
74157
74158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
74159   void * jresult ;
74160   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74161   Dali::Vector2 result;
74162
74163   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74164   {
74165     try {
74166       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
74167     } catch (std::out_of_range& e) {
74168       {
74169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74170       };
74171     } catch (std::exception& e) {
74172       {
74173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74174       };
74175     } catch (...) {
74176       {
74177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74178       };
74179     }
74180   }
74181   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74182   return jresult;
74183 }
74184
74185
74186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
74187   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74188   Dali::Vector2 *arg2 = 0 ;
74189
74190   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74191   arg2 = (Dali::Vector2 *)jarg2;
74192   if (!arg2) {
74193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74194     return ;
74195   }
74196   {
74197     try {
74198       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
74199     } catch (std::out_of_range& e) {
74200       {
74201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74202       };
74203     } catch (std::exception& e) {
74204       {
74205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74206       };
74207     } catch (...) {
74208       {
74209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74210       };
74211     }
74212   }
74213 }
74214
74215
74216 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
74217   float jresult ;
74218   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74219   float result;
74220
74221   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74222   {
74223     try {
74224       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
74225     } catch (std::out_of_range& e) {
74226       {
74227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74228       };
74229     } catch (std::exception& e) {
74230       {
74231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74232       };
74233     } catch (...) {
74234       {
74235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74236       };
74237     }
74238   }
74239   jresult = result;
74240   return jresult;
74241 }
74242
74243
74244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
74245   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74246   float arg2 ;
74247
74248   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74249   arg2 = (float)jarg2;
74250   {
74251     try {
74252       (arg1)->SetMinimumSpeedForFlick(arg2);
74253     } catch (std::out_of_range& e) {
74254       {
74255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74256       };
74257     } catch (std::exception& e) {
74258       {
74259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74260       };
74261     } catch (...) {
74262       {
74263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74264       };
74265     }
74266   }
74267 }
74268
74269
74270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
74271   float jresult ;
74272   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74273   float result;
74274
74275   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74276   {
74277     try {
74278       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
74279     } catch (std::out_of_range& e) {
74280       {
74281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74282       };
74283     } catch (std::exception& e) {
74284       {
74285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74286       };
74287     } catch (...) {
74288       {
74289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74290       };
74291     }
74292   }
74293   jresult = result;
74294   return jresult;
74295 }
74296
74297
74298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
74299   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74300   float arg2 ;
74301
74302   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74303   arg2 = (float)jarg2;
74304   {
74305     try {
74306       (arg1)->SetMaxFlickSpeed(arg2);
74307     } catch (std::out_of_range& e) {
74308       {
74309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74310       };
74311     } catch (std::exception& e) {
74312       {
74313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74314       };
74315     } catch (...) {
74316       {
74317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74318       };
74319     }
74320   }
74321 }
74322
74323
74324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
74325   void * jresult ;
74326   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74327   Dali::Vector2 result;
74328
74329   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74330   {
74331     try {
74332       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
74333     } catch (std::out_of_range& e) {
74334       {
74335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74336       };
74337     } catch (std::exception& e) {
74338       {
74339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74340       };
74341     } catch (...) {
74342       {
74343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74344       };
74345     }
74346   }
74347   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74348   return jresult;
74349 }
74350
74351
74352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
74353   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74354   Dali::Vector2 arg2 ;
74355   Dali::Vector2 *argp2 ;
74356
74357   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74358   argp2 = (Dali::Vector2 *)jarg2;
74359   if (!argp2) {
74360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
74361     return ;
74362   }
74363   arg2 = *argp2;
74364   {
74365     try {
74366       (arg1)->SetWheelScrollDistanceStep(arg2);
74367     } catch (std::out_of_range& e) {
74368       {
74369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74370       };
74371     } catch (std::exception& e) {
74372       {
74373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74374       };
74375     } catch (...) {
74376       {
74377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74378       };
74379     }
74380   }
74381 }
74382
74383
74384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
74385   void * jresult ;
74386   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74387   Dali::Vector2 result;
74388
74389   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74390   {
74391     try {
74392       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
74393     } catch (std::out_of_range& e) {
74394       {
74395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74396       };
74397     } catch (std::exception& e) {
74398       {
74399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74400       };
74401     } catch (...) {
74402       {
74403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74404       };
74405     }
74406   }
74407   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
74408   return jresult;
74409 }
74410
74411
74412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
74413   unsigned int jresult ;
74414   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74415   unsigned int result;
74416
74417   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74418   {
74419     try {
74420       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
74421     } catch (std::out_of_range& e) {
74422       {
74423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74424       };
74425     } catch (std::exception& e) {
74426       {
74427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74428       };
74429     } catch (...) {
74430       {
74431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74432       };
74433     }
74434   }
74435   jresult = result;
74436   return jresult;
74437 }
74438
74439
74440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
74441   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74442   Dali::Vector2 *arg2 = 0 ;
74443
74444   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74445   arg2 = (Dali::Vector2 *)jarg2;
74446   if (!arg2) {
74447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74448     return ;
74449   }
74450   {
74451     try {
74452       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
74453     } catch (std::out_of_range& e) {
74454       {
74455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74456       };
74457     } catch (std::exception& e) {
74458       {
74459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74460       };
74461     } catch (...) {
74462       {
74463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74464       };
74465     }
74466   }
74467 }
74468
74469
74470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
74471   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74472   Dali::Vector2 *arg2 = 0 ;
74473   float arg3 ;
74474
74475   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74476   arg2 = (Dali::Vector2 *)jarg2;
74477   if (!arg2) {
74478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74479     return ;
74480   }
74481   arg3 = (float)jarg3;
74482   {
74483     try {
74484       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
74485     } catch (std::out_of_range& e) {
74486       {
74487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74488       };
74489     } catch (std::exception& e) {
74490       {
74491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74492       };
74493     } catch (...) {
74494       {
74495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74496       };
74497     }
74498   }
74499 }
74500
74501
74502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
74503   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74504   Dali::Vector2 *arg2 = 0 ;
74505   float arg3 ;
74506   Dali::AlphaFunction arg4 ;
74507   Dali::AlphaFunction *argp4 ;
74508
74509   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74510   arg2 = (Dali::Vector2 *)jarg2;
74511   if (!arg2) {
74512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74513     return ;
74514   }
74515   arg3 = (float)jarg3;
74516   argp4 = (Dali::AlphaFunction *)jarg4;
74517   if (!argp4) {
74518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74519     return ;
74520   }
74521   arg4 = *argp4;
74522   {
74523     try {
74524       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
74525     } catch (std::out_of_range& e) {
74526       {
74527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74528       };
74529     } catch (std::exception& e) {
74530       {
74531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74532       };
74533     } catch (...) {
74534       {
74535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74536       };
74537     }
74538   }
74539 }
74540
74541
74542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
74543   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74544   Dali::Vector2 *arg2 = 0 ;
74545   float arg3 ;
74546   Dali::Toolkit::DirectionBias arg4 ;
74547   Dali::Toolkit::DirectionBias arg5 ;
74548
74549   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74550   arg2 = (Dali::Vector2 *)jarg2;
74551   if (!arg2) {
74552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74553     return ;
74554   }
74555   arg3 = (float)jarg3;
74556   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74557   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74558   {
74559     try {
74560       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
74561     } catch (std::out_of_range& e) {
74562       {
74563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74564       };
74565     } catch (std::exception& e) {
74566       {
74567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74568       };
74569     } catch (...) {
74570       {
74571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74572       };
74573     }
74574   }
74575 }
74576
74577
74578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
74579   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74580   Dali::Vector2 *arg2 = 0 ;
74581   float arg3 ;
74582   Dali::AlphaFunction arg4 ;
74583   Dali::Toolkit::DirectionBias arg5 ;
74584   Dali::Toolkit::DirectionBias arg6 ;
74585   Dali::AlphaFunction *argp4 ;
74586
74587   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74588   arg2 = (Dali::Vector2 *)jarg2;
74589   if (!arg2) {
74590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
74591     return ;
74592   }
74593   arg3 = (float)jarg3;
74594   argp4 = (Dali::AlphaFunction *)jarg4;
74595   if (!argp4) {
74596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74597     return ;
74598   }
74599   arg4 = *argp4;
74600   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
74601   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
74602   {
74603     try {
74604       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
74605     } catch (std::out_of_range& e) {
74606       {
74607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74608       };
74609     } catch (std::exception& e) {
74610       {
74611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74612       };
74613     } catch (...) {
74614       {
74615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74616       };
74617     }
74618   }
74619 }
74620
74621
74622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
74623   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74624   unsigned int arg2 ;
74625
74626   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74627   arg2 = (unsigned int)jarg2;
74628   {
74629     try {
74630       (arg1)->ScrollTo(arg2);
74631     } catch (std::out_of_range& e) {
74632       {
74633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74634       };
74635     } catch (std::exception& e) {
74636       {
74637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74638       };
74639     } catch (...) {
74640       {
74641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74642       };
74643     }
74644   }
74645 }
74646
74647
74648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
74649   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74650   unsigned int arg2 ;
74651   float arg3 ;
74652
74653   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74654   arg2 = (unsigned int)jarg2;
74655   arg3 = (float)jarg3;
74656   {
74657     try {
74658       (arg1)->ScrollTo(arg2,arg3);
74659     } catch (std::out_of_range& e) {
74660       {
74661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74662       };
74663     } catch (std::exception& e) {
74664       {
74665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74666       };
74667     } catch (...) {
74668       {
74669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74670       };
74671     }
74672   }
74673 }
74674
74675
74676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
74677   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74678   unsigned int arg2 ;
74679   float arg3 ;
74680   Dali::Toolkit::DirectionBias arg4 ;
74681
74682   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74683   arg2 = (unsigned int)jarg2;
74684   arg3 = (float)jarg3;
74685   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
74686   {
74687     try {
74688       (arg1)->ScrollTo(arg2,arg3,arg4);
74689     } catch (std::out_of_range& e) {
74690       {
74691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74692       };
74693     } catch (std::exception& e) {
74694       {
74695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74696       };
74697     } catch (...) {
74698       {
74699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74700       };
74701     }
74702   }
74703 }
74704
74705
74706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
74707   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74708   Dali::Actor *arg2 = 0 ;
74709
74710   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74711   arg2 = (Dali::Actor *)jarg2;
74712   if (!arg2) {
74713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74714     return ;
74715   }
74716   {
74717     try {
74718       (arg1)->ScrollTo(*arg2);
74719     } catch (std::out_of_range& e) {
74720       {
74721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74722       };
74723     } catch (std::exception& e) {
74724       {
74725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74726       };
74727     } catch (...) {
74728       {
74729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74730       };
74731     }
74732   }
74733 }
74734
74735
74736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
74737   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74738   Dali::Actor *arg2 = 0 ;
74739   float arg3 ;
74740
74741   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74742   arg2 = (Dali::Actor *)jarg2;
74743   if (!arg2) {
74744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74745     return ;
74746   }
74747   arg3 = (float)jarg3;
74748   {
74749     try {
74750       (arg1)->ScrollTo(*arg2,arg3);
74751     } catch (std::out_of_range& e) {
74752       {
74753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74754       };
74755     } catch (std::exception& e) {
74756       {
74757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74758       };
74759     } catch (...) {
74760       {
74761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74762       };
74763     }
74764   }
74765 }
74766
74767
74768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
74769   unsigned int jresult ;
74770   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74771   bool result;
74772
74773   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74774   {
74775     try {
74776       result = (bool)(arg1)->ScrollToSnapPoint();
74777     } catch (std::out_of_range& e) {
74778       {
74779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74780       };
74781     } catch (std::exception& e) {
74782       {
74783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74784       };
74785     } catch (...) {
74786       {
74787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74788       };
74789     }
74790   }
74791   jresult = result;
74792   return jresult;
74793 }
74794
74795
74796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
74797   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74798   Dali::Constraint arg2 ;
74799   Dali::Constraint *argp2 ;
74800
74801   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74802   argp2 = (Dali::Constraint *)jarg2;
74803   if (!argp2) {
74804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
74805     return ;
74806   }
74807   arg2 = *argp2;
74808   {
74809     try {
74810       (arg1)->ApplyConstraintToChildren(arg2);
74811     } catch (std::out_of_range& e) {
74812       {
74813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74814       };
74815     } catch (std::exception& e) {
74816       {
74817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74818       };
74819     } catch (...) {
74820       {
74821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74822       };
74823     }
74824   }
74825 }
74826
74827
74828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
74829   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74830
74831   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74832   {
74833     try {
74834       (arg1)->RemoveConstraintsFromChildren();
74835     } catch (std::out_of_range& e) {
74836       {
74837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74838       };
74839     } catch (std::exception& e) {
74840       {
74841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74842       };
74843     } catch (...) {
74844       {
74845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74846       };
74847     }
74848   }
74849 }
74850
74851
74852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
74853   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74854   Dali::Toolkit::ScrollViewEffect arg2 ;
74855   Dali::Toolkit::ScrollViewEffect *argp2 ;
74856
74857   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74858   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74859   if (!argp2) {
74860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74861     return ;
74862   }
74863   arg2 = *argp2;
74864   {
74865     try {
74866       (arg1)->ApplyEffect(arg2);
74867     } catch (std::out_of_range& e) {
74868       {
74869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74870       };
74871     } catch (std::exception& e) {
74872       {
74873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74874       };
74875     } catch (...) {
74876       {
74877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74878       };
74879     }
74880   }
74881 }
74882
74883
74884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
74885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74886   Dali::Toolkit::ScrollViewEffect arg2 ;
74887   Dali::Toolkit::ScrollViewEffect *argp2 ;
74888
74889   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74890   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
74891   if (!argp2) {
74892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
74893     return ;
74894   }
74895   arg2 = *argp2;
74896   {
74897     try {
74898       (arg1)->RemoveEffect(arg2);
74899     } catch (std::out_of_range& e) {
74900       {
74901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74902       };
74903     } catch (std::exception& e) {
74904       {
74905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74906       };
74907     } catch (...) {
74908       {
74909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74910       };
74911     }
74912   }
74913 }
74914
74915
74916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
74917   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74918
74919   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74920   {
74921     try {
74922       (arg1)->RemoveAllEffects();
74923     } catch (std::out_of_range& e) {
74924       {
74925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74926       };
74927     } catch (std::exception& e) {
74928       {
74929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74930       };
74931     } catch (...) {
74932       {
74933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74934       };
74935     }
74936   }
74937 }
74938
74939
74940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
74941   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74942   Dali::Actor arg2 ;
74943   Dali::Actor *argp2 ;
74944
74945   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74946   argp2 = (Dali::Actor *)jarg2;
74947   if (!argp2) {
74948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74949     return ;
74950   }
74951   arg2 = *argp2;
74952   {
74953     try {
74954       (arg1)->BindActor(arg2);
74955     } catch (std::out_of_range& e) {
74956       {
74957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74958       };
74959     } catch (std::exception& e) {
74960       {
74961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74962       };
74963     } catch (...) {
74964       {
74965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74966       };
74967     }
74968   }
74969 }
74970
74971
74972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
74973   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74974   Dali::Actor arg2 ;
74975   Dali::Actor *argp2 ;
74976
74977   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74978   argp2 = (Dali::Actor *)jarg2;
74979   if (!argp2) {
74980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74981     return ;
74982   }
74983   arg2 = *argp2;
74984   {
74985     try {
74986       (arg1)->UnbindActor(arg2);
74987     } catch (std::out_of_range& e) {
74988       {
74989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74990       };
74991     } catch (std::exception& e) {
74992       {
74993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74994       };
74995     } catch (...) {
74996       {
74997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74998       };
74999     }
75000   }
75001 }
75002
75003
75004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
75005   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75006   Dali::Radian arg2 ;
75007   Dali::Radian arg3 ;
75008   Dali::Radian *argp2 ;
75009   Dali::Radian *argp3 ;
75010
75011   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75012   argp2 = (Dali::Radian *)jarg2;
75013   if (!argp2) {
75014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75015     return ;
75016   }
75017   arg2 = *argp2;
75018   argp3 = (Dali::Radian *)jarg3;
75019   if (!argp3) {
75020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75021     return ;
75022   }
75023   arg3 = *argp3;
75024   {
75025     try {
75026       (arg1)->SetScrollingDirection(arg2,arg3);
75027     } catch (std::out_of_range& e) {
75028       {
75029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75030       };
75031     } catch (std::exception& e) {
75032       {
75033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75034       };
75035     } catch (...) {
75036       {
75037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75038       };
75039     }
75040   }
75041 }
75042
75043
75044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
75045   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75046   Dali::Radian arg2 ;
75047   Dali::Radian *argp2 ;
75048
75049   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75050   argp2 = (Dali::Radian *)jarg2;
75051   if (!argp2) {
75052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75053     return ;
75054   }
75055   arg2 = *argp2;
75056   {
75057     try {
75058       (arg1)->SetScrollingDirection(arg2);
75059     } catch (std::out_of_range& e) {
75060       {
75061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75062       };
75063     } catch (std::exception& e) {
75064       {
75065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75066       };
75067     } catch (...) {
75068       {
75069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75070       };
75071     }
75072   }
75073 }
75074
75075
75076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
75077   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75078   Dali::Radian arg2 ;
75079   Dali::Radian *argp2 ;
75080
75081   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75082   argp2 = (Dali::Radian *)jarg2;
75083   if (!argp2) {
75084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
75085     return ;
75086   }
75087   arg2 = *argp2;
75088   {
75089     try {
75090       (arg1)->RemoveScrollingDirection(arg2);
75091     } catch (std::out_of_range& e) {
75092       {
75093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75094       };
75095     } catch (std::exception& e) {
75096       {
75097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75098       };
75099     } catch (...) {
75100       {
75101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75102       };
75103     }
75104   }
75105 }
75106
75107
75108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
75109   void * jresult ;
75110   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75111   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
75112
75113   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75114   {
75115     try {
75116       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
75117     } catch (std::out_of_range& e) {
75118       {
75119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75120       };
75121     } catch (std::exception& e) {
75122       {
75123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75124       };
75125     } catch (...) {
75126       {
75127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75128       };
75129     }
75130   }
75131   jresult = (void *)result;
75132   return jresult;
75133 }
75134
75135
75136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
75137   int jresult ;
75138   int result;
75139
75140   result = (int)Dali::Toolkit::TableView::Property::ROWS;
75141   jresult = (int)result;
75142   return jresult;
75143 }
75144
75145
75146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
75147   int jresult ;
75148   int result;
75149
75150   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
75151   jresult = (int)result;
75152   return jresult;
75153 }
75154
75155
75156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
75157   int jresult ;
75158   int result;
75159
75160   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
75161   jresult = (int)result;
75162   return jresult;
75163 }
75164
75165
75166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
75167   int jresult ;
75168   int result;
75169
75170   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
75171   jresult = (int)result;
75172   return jresult;
75173 }
75174
75175
75176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
75177   int jresult ;
75178   int result;
75179
75180   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
75181   jresult = (int)result;
75182   return jresult;
75183 }
75184
75185
75186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
75187   void * jresult ;
75188   Dali::Toolkit::TableView::Property *result = 0 ;
75189
75190   {
75191     try {
75192       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
75193     } catch (std::out_of_range& e) {
75194       {
75195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75196       };
75197     } catch (std::exception& e) {
75198       {
75199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75200       };
75201     } catch (...) {
75202       {
75203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75204       };
75205     }
75206   }
75207   jresult = (void *)result;
75208   return jresult;
75209 }
75210
75211
75212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
75213   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
75214
75215   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
75216   {
75217     try {
75218       delete arg1;
75219     } catch (std::out_of_range& e) {
75220       {
75221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75222       };
75223     } catch (std::exception& e) {
75224       {
75225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75226       };
75227     } catch (...) {
75228       {
75229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75230       };
75231     }
75232   }
75233 }
75234
75235
75236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
75237   int jresult ;
75238   int result;
75239
75240   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
75241   jresult = (int)result;
75242   return jresult;
75243 }
75244
75245
75246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
75247   int jresult ;
75248   int result;
75249
75250   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
75251   jresult = (int)result;
75252   return jresult;
75253 }
75254
75255
75256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
75257   int jresult ;
75258   int result;
75259
75260   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
75261   jresult = (int)result;
75262   return jresult;
75263 }
75264
75265
75266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
75267   int jresult ;
75268   int result;
75269
75270   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
75271   jresult = (int)result;
75272   return jresult;
75273 }
75274
75275
75276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
75277   int jresult ;
75278   int result;
75279
75280   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
75281   jresult = (int)result;
75282   return jresult;
75283 }
75284
75285
75286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
75287   void * jresult ;
75288   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
75289
75290   {
75291     try {
75292       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
75293     } catch (std::out_of_range& e) {
75294       {
75295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75296       };
75297     } catch (std::exception& e) {
75298       {
75299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75300       };
75301     } catch (...) {
75302       {
75303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75304       };
75305     }
75306   }
75307   jresult = (void *)result;
75308   return jresult;
75309 }
75310
75311
75312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
75313   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
75314
75315   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
75316   {
75317     try {
75318       delete arg1;
75319     } catch (std::out_of_range& e) {
75320       {
75321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75322       };
75323     } catch (std::exception& e) {
75324       {
75325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75326       };
75327     } catch (...) {
75328       {
75329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75330       };
75331     }
75332   }
75333 }
75334
75335
75336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
75337   void * jresult ;
75338   unsigned int arg1 ;
75339   unsigned int arg2 ;
75340   unsigned int arg3 ;
75341   unsigned int arg4 ;
75342   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75343
75344   arg1 = (unsigned int)jarg1;
75345   arg2 = (unsigned int)jarg2;
75346   arg3 = (unsigned int)jarg3;
75347   arg4 = (unsigned int)jarg4;
75348   {
75349     try {
75350       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
75351     } catch (std::out_of_range& e) {
75352       {
75353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75354       };
75355     } catch (std::exception& e) {
75356       {
75357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75358       };
75359     } catch (...) {
75360       {
75361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75362       };
75363     }
75364   }
75365   jresult = (void *)result;
75366   return jresult;
75367 }
75368
75369
75370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
75371   void * jresult ;
75372   unsigned int arg1 ;
75373   unsigned int arg2 ;
75374   unsigned int arg3 ;
75375   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75376
75377   arg1 = (unsigned int)jarg1;
75378   arg2 = (unsigned int)jarg2;
75379   arg3 = (unsigned int)jarg3;
75380   {
75381     try {
75382       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
75383     } catch (std::out_of_range& e) {
75384       {
75385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75386       };
75387     } catch (std::exception& e) {
75388       {
75389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75390       };
75391     } catch (...) {
75392       {
75393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75394       };
75395     }
75396   }
75397   jresult = (void *)result;
75398   return jresult;
75399 }
75400
75401
75402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
75403   void * jresult ;
75404   unsigned int arg1 ;
75405   unsigned int arg2 ;
75406   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75407
75408   arg1 = (unsigned int)jarg1;
75409   arg2 = (unsigned int)jarg2;
75410   {
75411     try {
75412       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
75413     } catch (std::out_of_range& e) {
75414       {
75415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75416       };
75417     } catch (std::exception& e) {
75418       {
75419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75420       };
75421     } catch (...) {
75422       {
75423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75424       };
75425     }
75426   }
75427   jresult = (void *)result;
75428   return jresult;
75429 }
75430
75431
75432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
75433   void * jresult ;
75434   unsigned int arg1 ;
75435   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75436
75437   arg1 = (unsigned int)jarg1;
75438   {
75439     try {
75440       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
75441     } catch (std::out_of_range& e) {
75442       {
75443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75444       };
75445     } catch (std::exception& e) {
75446       {
75447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75448       };
75449     } catch (...) {
75450       {
75451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75452       };
75453     }
75454   }
75455   jresult = (void *)result;
75456   return jresult;
75457 }
75458
75459
75460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
75461   void * jresult ;
75462   Dali::Toolkit::TableView::CellPosition *result = 0 ;
75463
75464   {
75465     try {
75466       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
75467     } catch (std::out_of_range& e) {
75468       {
75469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75470       };
75471     } catch (std::exception& e) {
75472       {
75473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75474       };
75475     } catch (...) {
75476       {
75477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75478       };
75479     }
75480   }
75481   jresult = (void *)result;
75482   return jresult;
75483 }
75484
75485
75486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
75487   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75488   unsigned int arg2 ;
75489
75490   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75491   arg2 = (unsigned int)jarg2;
75492   if (arg1) (arg1)->rowIndex = arg2;
75493 }
75494
75495
75496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
75497   unsigned int jresult ;
75498   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75499   unsigned int result;
75500
75501   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75502   result = (unsigned int) ((arg1)->rowIndex);
75503   jresult = result;
75504   return jresult;
75505 }
75506
75507
75508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
75509   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75510   unsigned int arg2 ;
75511
75512   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75513   arg2 = (unsigned int)jarg2;
75514   if (arg1) (arg1)->columnIndex = arg2;
75515 }
75516
75517
75518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
75519   unsigned int jresult ;
75520   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75521   unsigned int result;
75522
75523   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75524   result = (unsigned int) ((arg1)->columnIndex);
75525   jresult = result;
75526   return jresult;
75527 }
75528
75529
75530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
75531   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75532   unsigned int arg2 ;
75533
75534   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75535   arg2 = (unsigned int)jarg2;
75536   if (arg1) (arg1)->rowSpan = arg2;
75537 }
75538
75539
75540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
75541   unsigned int jresult ;
75542   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75543   unsigned int result;
75544
75545   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75546   result = (unsigned int) ((arg1)->rowSpan);
75547   jresult = result;
75548   return jresult;
75549 }
75550
75551
75552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
75553   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75554   unsigned int arg2 ;
75555
75556   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75557   arg2 = (unsigned int)jarg2;
75558   if (arg1) (arg1)->columnSpan = arg2;
75559 }
75560
75561
75562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
75563   unsigned int jresult ;
75564   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75565   unsigned int result;
75566
75567   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75568   result = (unsigned int) ((arg1)->columnSpan);
75569   jresult = result;
75570   return jresult;
75571 }
75572
75573
75574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
75575   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
75576
75577   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
75578   {
75579     try {
75580       delete arg1;
75581     } catch (std::out_of_range& e) {
75582       {
75583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75584       };
75585     } catch (std::exception& e) {
75586       {
75587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75588       };
75589     } catch (...) {
75590       {
75591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75592       };
75593     }
75594   }
75595 }
75596
75597
75598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
75599   void * jresult ;
75600   Dali::Toolkit::TableView *result = 0 ;
75601
75602   {
75603     try {
75604       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
75605     } catch (std::out_of_range& e) {
75606       {
75607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75608       };
75609     } catch (std::exception& e) {
75610       {
75611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75612       };
75613     } catch (...) {
75614       {
75615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75616       };
75617     }
75618   }
75619   jresult = (void *)result;
75620   return jresult;
75621 }
75622
75623
75624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
75625   void * jresult ;
75626   Dali::Toolkit::TableView *arg1 = 0 ;
75627   Dali::Toolkit::TableView *result = 0 ;
75628
75629   arg1 = (Dali::Toolkit::TableView *)jarg1;
75630   if (!arg1) {
75631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75632     return 0;
75633   }
75634   {
75635     try {
75636       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
75637     } catch (std::out_of_range& e) {
75638       {
75639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75640       };
75641     } catch (std::exception& e) {
75642       {
75643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75644       };
75645     } catch (...) {
75646       {
75647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75648       };
75649     }
75650   }
75651   jresult = (void *)result;
75652   return jresult;
75653 }
75654
75655
75656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
75657   void * jresult ;
75658   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75659   Dali::Toolkit::TableView *arg2 = 0 ;
75660   Dali::Toolkit::TableView *result = 0 ;
75661
75662   arg1 = (Dali::Toolkit::TableView *)jarg1;
75663   arg2 = (Dali::Toolkit::TableView *)jarg2;
75664   if (!arg2) {
75665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
75666     return 0;
75667   }
75668   {
75669     try {
75670       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
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 = (void *)result;
75686   return jresult;
75687 }
75688
75689
75690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
75691   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75692
75693   arg1 = (Dali::Toolkit::TableView *)jarg1;
75694   {
75695     try {
75696       delete arg1;
75697     } catch (std::out_of_range& e) {
75698       {
75699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75700       };
75701     } catch (std::exception& e) {
75702       {
75703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75704       };
75705     } catch (...) {
75706       {
75707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75708       };
75709     }
75710   }
75711 }
75712
75713
75714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
75715   void * jresult ;
75716   unsigned int arg1 ;
75717   unsigned int arg2 ;
75718   Dali::Toolkit::TableView result;
75719
75720   arg1 = (unsigned int)jarg1;
75721   arg2 = (unsigned int)jarg2;
75722   {
75723     try {
75724       result = Dali::Toolkit::TableView::New(arg1,arg2);
75725     } catch (std::out_of_range& e) {
75726       {
75727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75728       };
75729     } catch (std::exception& e) {
75730       {
75731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75732       };
75733     } catch (...) {
75734       {
75735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75736       };
75737     }
75738   }
75739   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75740   return jresult;
75741 }
75742
75743
75744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
75745   void * jresult ;
75746   Dali::BaseHandle arg1 ;
75747   Dali::BaseHandle *argp1 ;
75748   Dali::Toolkit::TableView result;
75749
75750   argp1 = (Dali::BaseHandle *)jarg1;
75751   if (!argp1) {
75752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75753     return 0;
75754   }
75755   arg1 = *argp1;
75756   {
75757     try {
75758       result = Dali::Toolkit::TableView::DownCast(arg1);
75759     } catch (std::out_of_range& e) {
75760       {
75761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75762       };
75763     } catch (std::exception& e) {
75764       {
75765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75766       };
75767     } catch (...) {
75768       {
75769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75770       };
75771     }
75772   }
75773   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
75774   return jresult;
75775 }
75776
75777
75778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
75779   unsigned int jresult ;
75780   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75781   Dali::Actor arg2 ;
75782   Dali::Toolkit::TableView::CellPosition arg3 ;
75783   Dali::Actor *argp2 ;
75784   Dali::Toolkit::TableView::CellPosition *argp3 ;
75785   bool result;
75786
75787   arg1 = (Dali::Toolkit::TableView *)jarg1;
75788   argp2 = (Dali::Actor *)jarg2;
75789   if (!argp2) {
75790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75791     return 0;
75792   }
75793   arg2 = *argp2;
75794   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75795   if (!argp3) {
75796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75797     return 0;
75798   }
75799   arg3 = *argp3;
75800   {
75801     try {
75802       result = (bool)(arg1)->AddChild(arg2,arg3);
75803     } catch (std::out_of_range& e) {
75804       {
75805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75806       };
75807     } catch (std::exception& e) {
75808       {
75809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75810       };
75811     } catch (...) {
75812       {
75813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75814       };
75815     }
75816   }
75817   jresult = result;
75818   return jresult;
75819 }
75820
75821
75822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
75823   void * jresult ;
75824   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75825   Dali::Toolkit::TableView::CellPosition arg2 ;
75826   Dali::Toolkit::TableView::CellPosition *argp2 ;
75827   Dali::Actor result;
75828
75829   arg1 = (Dali::Toolkit::TableView *)jarg1;
75830   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75831   if (!argp2) {
75832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75833     return 0;
75834   }
75835   arg2 = *argp2;
75836   {
75837     try {
75838       result = (arg1)->GetChildAt(arg2);
75839     } catch (std::out_of_range& e) {
75840       {
75841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75842       };
75843     } catch (std::exception& e) {
75844       {
75845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75846       };
75847     } catch (...) {
75848       {
75849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75850       };
75851     }
75852   }
75853   jresult = new Dali::Actor((const Dali::Actor &)result);
75854   return jresult;
75855 }
75856
75857
75858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
75859   void * jresult ;
75860   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75861   Dali::Toolkit::TableView::CellPosition arg2 ;
75862   Dali::Toolkit::TableView::CellPosition *argp2 ;
75863   Dali::Actor result;
75864
75865   arg1 = (Dali::Toolkit::TableView *)jarg1;
75866   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
75867   if (!argp2) {
75868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
75869     return 0;
75870   }
75871   arg2 = *argp2;
75872   {
75873     try {
75874       result = (arg1)->RemoveChildAt(arg2);
75875     } catch (std::out_of_range& e) {
75876       {
75877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75878       };
75879     } catch (std::exception& e) {
75880       {
75881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75882       };
75883     } catch (...) {
75884       {
75885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75886       };
75887     }
75888   }
75889   jresult = new Dali::Actor((const Dali::Actor &)result);
75890   return jresult;
75891 }
75892
75893
75894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
75895   unsigned int jresult ;
75896   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75897   Dali::Actor arg2 ;
75898   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
75899   Dali::Actor *argp2 ;
75900   bool result;
75901
75902   arg1 = (Dali::Toolkit::TableView *)jarg1;
75903   argp2 = (Dali::Actor *)jarg2;
75904   if (!argp2) {
75905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75906     return 0;
75907   }
75908   arg2 = *argp2;
75909   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
75910   if (!arg3) {
75911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
75912     return 0;
75913   }
75914   {
75915     try {
75916       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
75917     } catch (std::out_of_range& e) {
75918       {
75919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75920       };
75921     } catch (std::exception& e) {
75922       {
75923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75924       };
75925     } catch (...) {
75926       {
75927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75928       };
75929     }
75930   }
75931   jresult = result;
75932   return jresult;
75933 }
75934
75935
75936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
75937   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75938   unsigned int arg2 ;
75939
75940   arg1 = (Dali::Toolkit::TableView *)jarg1;
75941   arg2 = (unsigned int)jarg2;
75942   {
75943     try {
75944       (arg1)->InsertRow(arg2);
75945     } catch (std::out_of_range& e) {
75946       {
75947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75948       };
75949     } catch (std::exception& e) {
75950       {
75951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75952       };
75953     } catch (...) {
75954       {
75955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75956       };
75957     }
75958   }
75959 }
75960
75961
75962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
75963   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75964   unsigned int arg2 ;
75965
75966   arg1 = (Dali::Toolkit::TableView *)jarg1;
75967   arg2 = (unsigned int)jarg2;
75968   {
75969     try {
75970       (arg1)->DeleteRow(arg2);
75971     } catch (std::out_of_range& e) {
75972       {
75973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75974       };
75975     } catch (std::exception& e) {
75976       {
75977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75978       };
75979     } catch (...) {
75980       {
75981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75982       };
75983     }
75984   }
75985 }
75986
75987
75988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
75989   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
75990   unsigned int arg2 ;
75991   std::vector< Dali::Actor > *arg3 = 0 ;
75992
75993   arg1 = (Dali::Toolkit::TableView *)jarg1;
75994   arg2 = (unsigned int)jarg2;
75995   arg3 = (std::vector< Dali::Actor > *)jarg3;
75996   if (!arg3) {
75997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
75998     return ;
75999   }
76000   {
76001     try {
76002       (arg1)->DeleteRow(arg2,*arg3);
76003     } catch (std::out_of_range& e) {
76004       {
76005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76006       };
76007     } catch (std::exception& e) {
76008       {
76009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76010       };
76011     } catch (...) {
76012       {
76013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76014       };
76015     }
76016   }
76017 }
76018
76019
76020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
76021   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76022   unsigned int arg2 ;
76023
76024   arg1 = (Dali::Toolkit::TableView *)jarg1;
76025   arg2 = (unsigned int)jarg2;
76026   {
76027     try {
76028       (arg1)->InsertColumn(arg2);
76029     } catch (std::out_of_range& e) {
76030       {
76031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76032       };
76033     } catch (std::exception& e) {
76034       {
76035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76036       };
76037     } catch (...) {
76038       {
76039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76040       };
76041     }
76042   }
76043 }
76044
76045
76046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
76047   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76048   unsigned int arg2 ;
76049
76050   arg1 = (Dali::Toolkit::TableView *)jarg1;
76051   arg2 = (unsigned int)jarg2;
76052   {
76053     try {
76054       (arg1)->DeleteColumn(arg2);
76055     } catch (std::out_of_range& e) {
76056       {
76057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76058       };
76059     } catch (std::exception& e) {
76060       {
76061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76062       };
76063     } catch (...) {
76064       {
76065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76066       };
76067     }
76068   }
76069 }
76070
76071
76072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
76073   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76074   unsigned int arg2 ;
76075   std::vector< Dali::Actor > *arg3 = 0 ;
76076
76077   arg1 = (Dali::Toolkit::TableView *)jarg1;
76078   arg2 = (unsigned int)jarg2;
76079   arg3 = (std::vector< Dali::Actor > *)jarg3;
76080   if (!arg3) {
76081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76082     return ;
76083   }
76084   {
76085     try {
76086       (arg1)->DeleteColumn(arg2,*arg3);
76087     } catch (std::out_of_range& e) {
76088       {
76089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76090       };
76091     } catch (std::exception& e) {
76092       {
76093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76094       };
76095     } catch (...) {
76096       {
76097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76098       };
76099     }
76100   }
76101 }
76102
76103
76104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
76105   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76106   unsigned int arg2 ;
76107   unsigned int arg3 ;
76108
76109   arg1 = (Dali::Toolkit::TableView *)jarg1;
76110   arg2 = (unsigned int)jarg2;
76111   arg3 = (unsigned int)jarg3;
76112   {
76113     try {
76114       (arg1)->Resize(arg2,arg3);
76115     } catch (std::out_of_range& e) {
76116       {
76117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76118       };
76119     } catch (std::exception& e) {
76120       {
76121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76122       };
76123     } catch (...) {
76124       {
76125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76126       };
76127     }
76128   }
76129 }
76130
76131
76132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
76133   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76134   unsigned int arg2 ;
76135   unsigned int arg3 ;
76136   std::vector< Dali::Actor > *arg4 = 0 ;
76137
76138   arg1 = (Dali::Toolkit::TableView *)jarg1;
76139   arg2 = (unsigned int)jarg2;
76140   arg3 = (unsigned int)jarg3;
76141   arg4 = (std::vector< Dali::Actor > *)jarg4;
76142   if (!arg4) {
76143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
76144     return ;
76145   }
76146   {
76147     try {
76148       (arg1)->Resize(arg2,arg3,*arg4);
76149     } catch (std::out_of_range& e) {
76150       {
76151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76152       };
76153     } catch (std::exception& e) {
76154       {
76155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76156       };
76157     } catch (...) {
76158       {
76159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76160       };
76161     }
76162   }
76163 }
76164
76165
76166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
76167   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76168   Dali::Size arg2 ;
76169   Dali::Size *argp2 ;
76170
76171   arg1 = (Dali::Toolkit::TableView *)jarg1;
76172   argp2 = (Dali::Size *)jarg2;
76173   if (!argp2) {
76174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
76175     return ;
76176   }
76177   arg2 = *argp2;
76178   {
76179     try {
76180       (arg1)->SetCellPadding(arg2);
76181     } catch (std::out_of_range& e) {
76182       {
76183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76184       };
76185     } catch (std::exception& e) {
76186       {
76187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76188       };
76189     } catch (...) {
76190       {
76191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76192       };
76193     }
76194   }
76195 }
76196
76197
76198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
76199   void * jresult ;
76200   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76201   Dali::Size result;
76202
76203   arg1 = (Dali::Toolkit::TableView *)jarg1;
76204   {
76205     try {
76206       result = (arg1)->GetCellPadding();
76207     } catch (std::out_of_range& e) {
76208       {
76209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76210       };
76211     } catch (std::exception& e) {
76212       {
76213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76214       };
76215     } catch (...) {
76216       {
76217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76218       };
76219     }
76220   }
76221   jresult = new Dali::Size((const Dali::Size &)result);
76222   return jresult;
76223 }
76224
76225
76226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
76227   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76228   unsigned int arg2 ;
76229
76230   arg1 = (Dali::Toolkit::TableView *)jarg1;
76231   arg2 = (unsigned int)jarg2;
76232   {
76233     try {
76234       (arg1)->SetFitHeight(arg2);
76235     } catch (std::out_of_range& e) {
76236       {
76237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76238       };
76239     } catch (std::exception& e) {
76240       {
76241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76242       };
76243     } catch (...) {
76244       {
76245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76246       };
76247     }
76248   }
76249 }
76250
76251
76252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
76253   unsigned int jresult ;
76254   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76255   unsigned int arg2 ;
76256   bool result;
76257
76258   arg1 = (Dali::Toolkit::TableView *)jarg1;
76259   arg2 = (unsigned int)jarg2;
76260   {
76261     try {
76262       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
76263     } catch (std::out_of_range& e) {
76264       {
76265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76266       };
76267     } catch (std::exception& e) {
76268       {
76269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76270       };
76271     } catch (...) {
76272       {
76273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76274       };
76275     }
76276   }
76277   jresult = result;
76278   return jresult;
76279 }
76280
76281
76282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
76283   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76284   unsigned int arg2 ;
76285
76286   arg1 = (Dali::Toolkit::TableView *)jarg1;
76287   arg2 = (unsigned int)jarg2;
76288   {
76289     try {
76290       (arg1)->SetFitWidth(arg2);
76291     } catch (std::out_of_range& e) {
76292       {
76293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76294       };
76295     } catch (std::exception& e) {
76296       {
76297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76298       };
76299     } catch (...) {
76300       {
76301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76302       };
76303     }
76304   }
76305 }
76306
76307
76308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
76309   unsigned int jresult ;
76310   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76311   unsigned int arg2 ;
76312   bool result;
76313
76314   arg1 = (Dali::Toolkit::TableView *)jarg1;
76315   arg2 = (unsigned int)jarg2;
76316   {
76317     try {
76318       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
76319     } catch (std::out_of_range& e) {
76320       {
76321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76322       };
76323     } catch (std::exception& e) {
76324       {
76325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76326       };
76327     } catch (...) {
76328       {
76329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76330       };
76331     }
76332   }
76333   jresult = result;
76334   return jresult;
76335 }
76336
76337
76338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76339   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76340   unsigned int arg2 ;
76341   float arg3 ;
76342
76343   arg1 = (Dali::Toolkit::TableView *)jarg1;
76344   arg2 = (unsigned int)jarg2;
76345   arg3 = (float)jarg3;
76346   {
76347     try {
76348       (arg1)->SetFixedHeight(arg2,arg3);
76349     } catch (std::out_of_range& e) {
76350       {
76351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76352       };
76353     } catch (std::exception& e) {
76354       {
76355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76356       };
76357     } catch (...) {
76358       {
76359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76360       };
76361     }
76362   }
76363 }
76364
76365
76366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
76367   float jresult ;
76368   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76369   unsigned int arg2 ;
76370   float result;
76371
76372   arg1 = (Dali::Toolkit::TableView *)jarg1;
76373   arg2 = (unsigned int)jarg2;
76374   {
76375     try {
76376       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
76377     } catch (std::out_of_range& e) {
76378       {
76379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76380       };
76381     } catch (std::exception& e) {
76382       {
76383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76384       };
76385     } catch (...) {
76386       {
76387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76388       };
76389     }
76390   }
76391   jresult = result;
76392   return jresult;
76393 }
76394
76395
76396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
76397   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76398   unsigned int arg2 ;
76399   float arg3 ;
76400
76401   arg1 = (Dali::Toolkit::TableView *)jarg1;
76402   arg2 = (unsigned int)jarg2;
76403   arg3 = (float)jarg3;
76404   {
76405     try {
76406       (arg1)->SetRelativeHeight(arg2,arg3);
76407     } catch (std::out_of_range& e) {
76408       {
76409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76410       };
76411     } catch (std::exception& e) {
76412       {
76413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76414       };
76415     } catch (...) {
76416       {
76417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76418       };
76419     }
76420   }
76421 }
76422
76423
76424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
76425   float jresult ;
76426   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76427   unsigned int arg2 ;
76428   float result;
76429
76430   arg1 = (Dali::Toolkit::TableView *)jarg1;
76431   arg2 = (unsigned int)jarg2;
76432   {
76433     try {
76434       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
76435     } catch (std::out_of_range& e) {
76436       {
76437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76438       };
76439     } catch (std::exception& e) {
76440       {
76441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76442       };
76443     } catch (...) {
76444       {
76445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76446       };
76447     }
76448   }
76449   jresult = result;
76450   return jresult;
76451 }
76452
76453
76454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76455   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76456   unsigned int arg2 ;
76457   float arg3 ;
76458
76459   arg1 = (Dali::Toolkit::TableView *)jarg1;
76460   arg2 = (unsigned int)jarg2;
76461   arg3 = (float)jarg3;
76462   {
76463     try {
76464       (arg1)->SetFixedWidth(arg2,arg3);
76465     } catch (std::out_of_range& e) {
76466       {
76467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76468       };
76469     } catch (std::exception& e) {
76470       {
76471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76472       };
76473     } catch (...) {
76474       {
76475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76476       };
76477     }
76478   }
76479 }
76480
76481
76482 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
76483   float jresult ;
76484   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76485   unsigned int arg2 ;
76486   float result;
76487
76488   arg1 = (Dali::Toolkit::TableView *)jarg1;
76489   arg2 = (unsigned int)jarg2;
76490   {
76491     try {
76492       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
76493     } catch (std::out_of_range& e) {
76494       {
76495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76496       };
76497     } catch (std::exception& e) {
76498       {
76499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76500       };
76501     } catch (...) {
76502       {
76503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76504       };
76505     }
76506   }
76507   jresult = result;
76508   return jresult;
76509 }
76510
76511
76512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
76513   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76514   unsigned int arg2 ;
76515   float arg3 ;
76516
76517   arg1 = (Dali::Toolkit::TableView *)jarg1;
76518   arg2 = (unsigned int)jarg2;
76519   arg3 = (float)jarg3;
76520   {
76521     try {
76522       (arg1)->SetRelativeWidth(arg2,arg3);
76523     } catch (std::out_of_range& e) {
76524       {
76525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76526       };
76527     } catch (std::exception& e) {
76528       {
76529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76530       };
76531     } catch (...) {
76532       {
76533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76534       };
76535     }
76536   }
76537 }
76538
76539
76540 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
76541   float jresult ;
76542   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76543   unsigned int arg2 ;
76544   float result;
76545
76546   arg1 = (Dali::Toolkit::TableView *)jarg1;
76547   arg2 = (unsigned int)jarg2;
76548   {
76549     try {
76550       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
76551     } catch (std::out_of_range& e) {
76552       {
76553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76554       };
76555     } catch (std::exception& e) {
76556       {
76557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76558       };
76559     } catch (...) {
76560       {
76561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76562       };
76563     }
76564   }
76565   jresult = result;
76566   return jresult;
76567 }
76568
76569
76570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
76571   unsigned int jresult ;
76572   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76573   unsigned int result;
76574
76575   arg1 = (Dali::Toolkit::TableView *)jarg1;
76576   {
76577     try {
76578       result = (unsigned int)(arg1)->GetRows();
76579     } catch (std::out_of_range& e) {
76580       {
76581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76582       };
76583     } catch (std::exception& e) {
76584       {
76585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76586       };
76587     } catch (...) {
76588       {
76589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76590       };
76591     }
76592   }
76593   jresult = result;
76594   return jresult;
76595 }
76596
76597
76598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
76599   unsigned int jresult ;
76600   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76601   unsigned int result;
76602
76603   arg1 = (Dali::Toolkit::TableView *)jarg1;
76604   {
76605     try {
76606       result = (unsigned int)(arg1)->GetColumns();
76607     } catch (std::out_of_range& e) {
76608       {
76609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76610       };
76611     } catch (std::exception& e) {
76612       {
76613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76614       };
76615     } catch (...) {
76616       {
76617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76618       };
76619     }
76620   }
76621   jresult = result;
76622   return jresult;
76623 }
76624
76625
76626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
76627   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
76628   Dali::Toolkit::TableView::CellPosition arg2 ;
76629   Dali::HorizontalAlignment::Type arg3 ;
76630   Dali::VerticalAlignment::Type arg4 ;
76631   Dali::Toolkit::TableView::CellPosition *argp2 ;
76632
76633   arg1 = (Dali::Toolkit::TableView *)jarg1;
76634   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
76635   if (!argp2) {
76636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
76637     return ;
76638   }
76639   arg2 = *argp2;
76640   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
76641   arg4 = (Dali::VerticalAlignment::Type)jarg4;
76642   {
76643     try {
76644       (arg1)->SetCellAlignment(arg2,arg3,arg4);
76645     } catch (std::out_of_range& e) {
76646       {
76647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76648       };
76649     } catch (std::exception& e) {
76650       {
76651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76652       };
76653     } catch (...) {
76654       {
76655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76656       };
76657     }
76658   }
76659 }
76660
76661
76662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
76663   unsigned int jresult ;
76664   unsigned int result;
76665
76666   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
76667   jresult = result;
76668   return jresult;
76669 }
76670
76671
76672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_RENDERING_BACKEND_get() {
76673   int jresult ;
76674   int result;
76675
76676   result = (int)Dali::Toolkit::TextEditor::Property::RENDERING_BACKEND;
76677   jresult = (int)result;
76678   return jresult;
76679 }
76680
76681
76682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_get() {
76683   int jresult ;
76684   int result;
76685
76686   result = (int)Dali::Toolkit::TextEditor::Property::TEXT;
76687   jresult = (int)result;
76688   return jresult;
76689 }
76690
76691
76692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_TEXT_COLOR_get() {
76693   int jresult ;
76694   int result;
76695
76696   result = (int)Dali::Toolkit::TextEditor::Property::TEXT_COLOR;
76697   jresult = (int)result;
76698   return jresult;
76699 }
76700
76701
76702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_FAMILY_get() {
76703   int jresult ;
76704   int result;
76705
76706   result = (int)Dali::Toolkit::TextEditor::Property::FONT_FAMILY;
76707   jresult = (int)result;
76708   return jresult;
76709 }
76710
76711
76712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_FONT_STYLE_get() {
76713   int jresult ;
76714   int result;
76715
76716   result = (int)Dali::Toolkit::TextEditor::Property::FONT_STYLE;
76717   jresult = (int)result;
76718   return jresult;
76719 }
76720
76721
76722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_POINT_SIZE_get() {
76723   int jresult ;
76724   int result;
76725
76726   result = (int)Dali::Toolkit::TextEditor::Property::POINT_SIZE;
76727   jresult = (int)result;
76728   return jresult;
76729 }
76730
76731
76732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_HORIZONTAL_ALIGNMENT_get() {
76733   int jresult ;
76734   int result;
76735
76736   result = (int)Dali::Toolkit::TextEditor::Property::HORIZONTAL_ALIGNMENT;
76737   jresult = (int)result;
76738   return jresult;
76739 }
76740
76741
76742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_THRESHOLD_get() {
76743   int jresult ;
76744   int result;
76745
76746   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_THRESHOLD;
76747   jresult = (int)result;
76748   return jresult;
76749 }
76750
76751
76752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SCROLL_SPEED_get() {
76753   int jresult ;
76754   int result;
76755
76756   result = (int)Dali::Toolkit::TextEditor::Property::SCROLL_SPEED;
76757   jresult = (int)result;
76758   return jresult;
76759 }
76760
76761
76762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_PRIMARY_CURSOR_COLOR_get() {
76763   int jresult ;
76764   int result;
76765
76766   result = (int)Dali::Toolkit::TextEditor::Property::PRIMARY_CURSOR_COLOR;
76767   jresult = (int)result;
76768   return jresult;
76769 }
76770
76771
76772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SECONDARY_CURSOR_COLOR_get() {
76773   int jresult ;
76774   int result;
76775
76776   result = (int)Dali::Toolkit::TextEditor::Property::SECONDARY_CURSOR_COLOR;
76777   jresult = (int)result;
76778   return jresult;
76779 }
76780
76781
76782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_CURSOR_BLINK_get() {
76783   int jresult ;
76784   int result;
76785
76786   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_CURSOR_BLINK;
76787   jresult = (int)result;
76788   return jresult;
76789 }
76790
76791
76792 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_INTERVAL_get() {
76793   int jresult ;
76794   int result;
76795
76796   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_INTERVAL;
76797   jresult = (int)result;
76798   return jresult;
76799 }
76800
76801
76802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_BLINK_DURATION_get() {
76803   int jresult ;
76804   int result;
76805
76806   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_BLINK_DURATION;
76807   jresult = (int)result;
76808   return jresult;
76809 }
76810
76811
76812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_CURSOR_WIDTH_get() {
76813   int jresult ;
76814   int result;
76815
76816   result = (int)Dali::Toolkit::TextEditor::Property::CURSOR_WIDTH;
76817   jresult = (int)result;
76818   return jresult;
76819 }
76820
76821
76822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_IMAGE_get() {
76823   int jresult ;
76824   int result;
76825
76826   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_IMAGE;
76827   jresult = (int)result;
76828   return jresult;
76829 }
76830
76831
76832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
76833   int jresult ;
76834   int result;
76835
76836   result = (int)Dali::Toolkit::TextEditor::Property::GRAB_HANDLE_PRESSED_IMAGE;
76837   jresult = (int)result;
76838   return jresult;
76839 }
76840
76841
76842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
76843   int jresult ;
76844   int result;
76845
76846   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT;
76847   jresult = (int)result;
76848   return jresult;
76849 }
76850
76851
76852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
76853   int jresult ;
76854   int result;
76855
76856   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT;
76857   jresult = (int)result;
76858   return jresult;
76859 }
76860
76861
76862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
76863   int jresult ;
76864   int result;
76865
76866   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
76867   jresult = (int)result;
76868   return jresult;
76869 }
76870
76871
76872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
76873   int jresult ;
76874   int result;
76875
76876   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
76877   jresult = (int)result;
76878   return jresult;
76879 }
76880
76881
76882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
76883   int jresult ;
76884   int result;
76885
76886   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
76887   jresult = (int)result;
76888   return jresult;
76889 }
76890
76891
76892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
76893   int jresult ;
76894   int result;
76895
76896   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
76897   jresult = (int)result;
76898   return jresult;
76899 }
76900
76901
76902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SELECTION_HIGHLIGHT_COLOR_get() {
76903   int jresult ;
76904   int result;
76905
76906   result = (int)Dali::Toolkit::TextEditor::Property::SELECTION_HIGHLIGHT_COLOR;
76907   jresult = (int)result;
76908   return jresult;
76909 }
76910
76911
76912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_DECORATION_BOUNDING_BOX_get() {
76913   int jresult ;
76914   int result;
76915
76916   result = (int)Dali::Toolkit::TextEditor::Property::DECORATION_BOUNDING_BOX;
76917   jresult = (int)result;
76918   return jresult;
76919 }
76920
76921
76922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_ENABLE_MARKUP_get() {
76923   int jresult ;
76924   int result;
76925
76926   result = (int)Dali::Toolkit::TextEditor::Property::ENABLE_MARKUP;
76927   jresult = (int)result;
76928   return jresult;
76929 }
76930
76931
76932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_COLOR_get() {
76933   int jresult ;
76934   int result;
76935
76936   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_COLOR;
76937   jresult = (int)result;
76938   return jresult;
76939 }
76940
76941
76942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_FAMILY_get() {
76943   int jresult ;
76944   int result;
76945
76946   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_FAMILY;
76947   jresult = (int)result;
76948   return jresult;
76949 }
76950
76951
76952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_FONT_STYLE_get() {
76953   int jresult ;
76954   int result;
76955
76956   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_FONT_STYLE;
76957   jresult = (int)result;
76958   return jresult;
76959 }
76960
76961
76962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_POINT_SIZE_get() {
76963   int jresult ;
76964   int result;
76965
76966   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_POINT_SIZE;
76967   jresult = (int)result;
76968   return jresult;
76969 }
76970
76971
76972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_LINE_SPACING_get() {
76973   int jresult ;
76974   int result;
76975
76976   result = (int)Dali::Toolkit::TextEditor::Property::LINE_SPACING;
76977   jresult = (int)result;
76978   return jresult;
76979 }
76980
76981
76982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_LINE_SPACING_get() {
76983   int jresult ;
76984   int result;
76985
76986   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_LINE_SPACING;
76987   jresult = (int)result;
76988   return jresult;
76989 }
76990
76991
76992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_UNDERLINE_get() {
76993   int jresult ;
76994   int result;
76995
76996   result = (int)Dali::Toolkit::TextEditor::Property::UNDERLINE;
76997   jresult = (int)result;
76998   return jresult;
76999 }
77000
77001
77002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_UNDERLINE_get() {
77003   int jresult ;
77004   int result;
77005
77006   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_UNDERLINE;
77007   jresult = (int)result;
77008   return jresult;
77009 }
77010
77011
77012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_SHADOW_get() {
77013   int jresult ;
77014   int result;
77015
77016   result = (int)Dali::Toolkit::TextEditor::Property::SHADOW;
77017   jresult = (int)result;
77018   return jresult;
77019 }
77020
77021
77022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_SHADOW_get() {
77023   int jresult ;
77024   int result;
77025
77026   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_SHADOW;
77027   jresult = (int)result;
77028   return jresult;
77029 }
77030
77031
77032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_EMBOSS_get() {
77033   int jresult ;
77034   int result;
77035
77036   result = (int)Dali::Toolkit::TextEditor::Property::EMBOSS;
77037   jresult = (int)result;
77038   return jresult;
77039 }
77040
77041
77042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_EMBOSS_get() {
77043   int jresult ;
77044   int result;
77045
77046   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_EMBOSS;
77047   jresult = (int)result;
77048   return jresult;
77049 }
77050
77051
77052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_OUTLINE_get() {
77053   int jresult ;
77054   int result;
77055
77056   result = (int)Dali::Toolkit::TextEditor::Property::OUTLINE;
77057   jresult = (int)result;
77058   return jresult;
77059 }
77060
77061
77062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextEditor_Property_INPUT_OUTLINE_get() {
77063   int jresult ;
77064   int result;
77065
77066   result = (int)Dali::Toolkit::TextEditor::Property::INPUT_OUTLINE;
77067   jresult = (int)result;
77068   return jresult;
77069 }
77070
77071
77072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_Property() {
77073   void * jresult ;
77074   Dali::Toolkit::TextEditor::Property *result = 0 ;
77075
77076   {
77077     try {
77078       result = (Dali::Toolkit::TextEditor::Property *)new Dali::Toolkit::TextEditor::Property();
77079     } catch (std::out_of_range& e) {
77080       {
77081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77082       };
77083     } catch (std::exception& e) {
77084       {
77085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77086       };
77087     } catch (...) {
77088       {
77089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77090       };
77091     }
77092   }
77093   jresult = (void *)result;
77094   return jresult;
77095 }
77096
77097
77098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_Property(void * jarg1) {
77099   Dali::Toolkit::TextEditor::Property *arg1 = (Dali::Toolkit::TextEditor::Property *) 0 ;
77100
77101   arg1 = (Dali::Toolkit::TextEditor::Property *)jarg1;
77102   {
77103     try {
77104       delete arg1;
77105     } catch (std::out_of_range& e) {
77106       {
77107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77108       };
77109     } catch (std::exception& e) {
77110       {
77111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77112       };
77113     } catch (...) {
77114       {
77115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77116       };
77117     }
77118   }
77119 }
77120
77121
77122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor_InputStyle() {
77123   void * jresult ;
77124   Dali::Toolkit::TextEditor::InputStyle *result = 0 ;
77125
77126   {
77127     try {
77128       result = (Dali::Toolkit::TextEditor::InputStyle *)new Dali::Toolkit::TextEditor::InputStyle();
77129     } catch (std::out_of_range& e) {
77130       {
77131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77132       };
77133     } catch (std::exception& e) {
77134       {
77135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77136       };
77137     } catch (...) {
77138       {
77139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77140       };
77141     }
77142   }
77143   jresult = (void *)result;
77144   return jresult;
77145 }
77146
77147
77148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor_InputStyle(void * jarg1) {
77149   Dali::Toolkit::TextEditor::InputStyle *arg1 = (Dali::Toolkit::TextEditor::InputStyle *) 0 ;
77150
77151   arg1 = (Dali::Toolkit::TextEditor::InputStyle *)jarg1;
77152   {
77153     try {
77154       delete arg1;
77155     } catch (std::out_of_range& e) {
77156       {
77157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77158       };
77159     } catch (std::exception& e) {
77160       {
77161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77162       };
77163     } catch (...) {
77164       {
77165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77166       };
77167     }
77168   }
77169 }
77170
77171
77172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_New() {
77173   void * jresult ;
77174   Dali::Toolkit::TextEditor result;
77175
77176   {
77177     try {
77178       result = Dali::Toolkit::TextEditor::New();
77179     } catch (std::out_of_range& e) {
77180       {
77181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77182       };
77183     } catch (std::exception& e) {
77184       {
77185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77186       };
77187     } catch (...) {
77188       {
77189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77190       };
77191     }
77192   }
77193   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77194   return jresult;
77195 }
77196
77197
77198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_0() {
77199   void * jresult ;
77200   Dali::Toolkit::TextEditor *result = 0 ;
77201
77202   {
77203     try {
77204       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor();
77205     } catch (std::out_of_range& e) {
77206       {
77207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77208       };
77209     } catch (std::exception& e) {
77210       {
77211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77212       };
77213     } catch (...) {
77214       {
77215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77216       };
77217     }
77218   }
77219   jresult = (void *)result;
77220   return jresult;
77221 }
77222
77223
77224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditor__SWIG_1(void * jarg1) {
77225   void * jresult ;
77226   Dali::Toolkit::TextEditor *arg1 = 0 ;
77227   Dali::Toolkit::TextEditor *result = 0 ;
77228
77229   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77230   if (!arg1) {
77231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77232     return 0;
77233   }
77234   {
77235     try {
77236       result = (Dali::Toolkit::TextEditor *)new Dali::Toolkit::TextEditor((Dali::Toolkit::TextEditor const &)*arg1);
77237     } catch (std::out_of_range& e) {
77238       {
77239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77240       };
77241     } catch (std::exception& e) {
77242       {
77243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77244       };
77245     } catch (...) {
77246       {
77247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77248       };
77249     }
77250   }
77251   jresult = (void *)result;
77252   return jresult;
77253 }
77254
77255
77256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_Assign(void * jarg1, void * jarg2) {
77257   void * jresult ;
77258   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77259   Dali::Toolkit::TextEditor *arg2 = 0 ;
77260   Dali::Toolkit::TextEditor *result = 0 ;
77261
77262   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77263   arg2 = (Dali::Toolkit::TextEditor *)jarg2;
77264   if (!arg2) {
77265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextEditor const & type is null", 0);
77266     return 0;
77267   }
77268   {
77269     try {
77270       result = (Dali::Toolkit::TextEditor *) &(arg1)->operator =((Dali::Toolkit::TextEditor const &)*arg2);
77271     } catch (std::out_of_range& e) {
77272       {
77273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77274       };
77275     } catch (std::exception& e) {
77276       {
77277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77278       };
77279     } catch (...) {
77280       {
77281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77282       };
77283     }
77284   }
77285   jresult = (void *)result;
77286   return jresult;
77287 }
77288
77289
77290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditor(void * jarg1) {
77291   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77292
77293   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77294   {
77295     try {
77296       delete arg1;
77297     } catch (std::out_of_range& e) {
77298       {
77299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77300       };
77301     } catch (std::exception& e) {
77302       {
77303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77304       };
77305     } catch (...) {
77306       {
77307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77308       };
77309     }
77310   }
77311 }
77312
77313
77314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_DownCast(void * jarg1) {
77315   void * jresult ;
77316   Dali::BaseHandle arg1 ;
77317   Dali::BaseHandle *argp1 ;
77318   Dali::Toolkit::TextEditor result;
77319
77320   argp1 = (Dali::BaseHandle *)jarg1;
77321   if (!argp1) {
77322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77323     return 0;
77324   }
77325   arg1 = *argp1;
77326   {
77327     try {
77328       result = Dali::Toolkit::TextEditor::DownCast(arg1);
77329     } catch (std::out_of_range& e) {
77330       {
77331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77332       };
77333     } catch (std::exception& e) {
77334       {
77335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77336       };
77337     } catch (...) {
77338       {
77339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77340       };
77341     }
77342   }
77343   jresult = new Dali::Toolkit::TextEditor((const Dali::Toolkit::TextEditor &)result);
77344   return jresult;
77345 }
77346
77347
77348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_TextChangedSignal(void * jarg1) {
77349   void * jresult ;
77350   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77351   Dali::Toolkit::TextEditor::TextChangedSignalType *result = 0 ;
77352
77353   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77354   {
77355     try {
77356       result = (Dali::Toolkit::TextEditor::TextChangedSignalType *) &(arg1)->TextChangedSignal();
77357     } catch (std::out_of_range& e) {
77358       {
77359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77360       };
77361     } catch (std::exception& e) {
77362       {
77363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77364       };
77365     } catch (...) {
77366       {
77367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77368       };
77369     }
77370   }
77371   jresult = (void *)result;
77372   return jresult;
77373 }
77374
77375
77376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextEditor_InputStyleChangedSignal(void * jarg1) {
77377   void * jresult ;
77378   Dali::Toolkit::TextEditor *arg1 = (Dali::Toolkit::TextEditor *) 0 ;
77379   Dali::Toolkit::TextEditor::InputStyleChangedSignalType *result = 0 ;
77380
77381   arg1 = (Dali::Toolkit::TextEditor *)jarg1;
77382   {
77383     try {
77384       result = (Dali::Toolkit::TextEditor::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
77385     } catch (std::out_of_range& e) {
77386       {
77387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77388       };
77389     } catch (std::exception& e) {
77390       {
77391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77392       };
77393     } catch (...) {
77394       {
77395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77396       };
77397     }
77398   }
77399   jresult = (void *)result;
77400   return jresult;
77401 }
77402
77403
77404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_RENDERING_BACKEND_get() {
77405   int jresult ;
77406   int result;
77407
77408   result = (int)Dali::Toolkit::TextField::Property::RENDERING_BACKEND;
77409   jresult = (int)result;
77410   return jresult;
77411 }
77412
77413
77414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_get() {
77415   int jresult ;
77416   int result;
77417
77418   result = (int)Dali::Toolkit::TextField::Property::TEXT;
77419   jresult = (int)result;
77420   return jresult;
77421 }
77422
77423
77424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_get() {
77425   int jresult ;
77426   int result;
77427
77428   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT;
77429   jresult = (int)result;
77430   return jresult;
77431 }
77432
77433
77434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_FOCUSED_get() {
77435   int jresult ;
77436   int result;
77437
77438   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_FOCUSED;
77439   jresult = (int)result;
77440   return jresult;
77441 }
77442
77443
77444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_FAMILY_get() {
77445   int jresult ;
77446   int result;
77447
77448   result = (int)Dali::Toolkit::TextField::Property::FONT_FAMILY;
77449   jresult = (int)result;
77450   return jresult;
77451 }
77452
77453
77454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_FONT_STYLE_get() {
77455   int jresult ;
77456   int result;
77457
77458   result = (int)Dali::Toolkit::TextField::Property::FONT_STYLE;
77459   jresult = (int)result;
77460   return jresult;
77461 }
77462
77463
77464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_POINT_SIZE_get() {
77465   int jresult ;
77466   int result;
77467
77468   result = (int)Dali::Toolkit::TextField::Property::POINT_SIZE;
77469   jresult = (int)result;
77470   return jresult;
77471 }
77472
77473
77474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_MAX_LENGTH_get() {
77475   int jresult ;
77476   int result;
77477
77478   result = (int)Dali::Toolkit::TextField::Property::MAX_LENGTH;
77479   jresult = (int)result;
77480   return jresult;
77481 }
77482
77483
77484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EXCEED_POLICY_get() {
77485   int jresult ;
77486   int result;
77487
77488   result = (int)Dali::Toolkit::TextField::Property::EXCEED_POLICY;
77489   jresult = (int)result;
77490   return jresult;
77491 }
77492
77493
77494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_HORIZONTAL_ALIGNMENT_get() {
77495   int jresult ;
77496   int result;
77497
77498   result = (int)Dali::Toolkit::TextField::Property::HORIZONTAL_ALIGNMENT;
77499   jresult = (int)result;
77500   return jresult;
77501 }
77502
77503
77504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_VERTICAL_ALIGNMENT_get() {
77505   int jresult ;
77506   int result;
77507
77508   result = (int)Dali::Toolkit::TextField::Property::VERTICAL_ALIGNMENT;
77509   jresult = (int)result;
77510   return jresult;
77511 }
77512
77513
77514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_TEXT_COLOR_get() {
77515   int jresult ;
77516   int result;
77517
77518   result = (int)Dali::Toolkit::TextField::Property::TEXT_COLOR;
77519   jresult = (int)result;
77520   return jresult;
77521 }
77522
77523
77524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PLACEHOLDER_TEXT_COLOR_get() {
77525   int jresult ;
77526   int result;
77527
77528   result = (int)Dali::Toolkit::TextField::Property::PLACEHOLDER_TEXT_COLOR;
77529   jresult = (int)result;
77530   return jresult;
77531 }
77532
77533
77534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_OFFSET_get() {
77535   int jresult ;
77536   int result;
77537
77538   result = (int)Dali::Toolkit::TextField::Property::SHADOW_OFFSET;
77539   jresult = (int)result;
77540   return jresult;
77541 }
77542
77543
77544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_COLOR_get() {
77545   int jresult ;
77546   int result;
77547
77548   result = (int)Dali::Toolkit::TextField::Property::SHADOW_COLOR;
77549   jresult = (int)result;
77550   return jresult;
77551 }
77552
77553
77554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_PRIMARY_CURSOR_COLOR_get() {
77555   int jresult ;
77556   int result;
77557
77558   result = (int)Dali::Toolkit::TextField::Property::PRIMARY_CURSOR_COLOR;
77559   jresult = (int)result;
77560   return jresult;
77561 }
77562
77563
77564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SECONDARY_CURSOR_COLOR_get() {
77565   int jresult ;
77566   int result;
77567
77568   result = (int)Dali::Toolkit::TextField::Property::SECONDARY_CURSOR_COLOR;
77569   jresult = (int)result;
77570   return jresult;
77571 }
77572
77573
77574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_CURSOR_BLINK_get() {
77575   int jresult ;
77576   int result;
77577
77578   result = (int)Dali::Toolkit::TextField::Property::ENABLE_CURSOR_BLINK;
77579   jresult = (int)result;
77580   return jresult;
77581 }
77582
77583
77584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_INTERVAL_get() {
77585   int jresult ;
77586   int result;
77587
77588   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_INTERVAL;
77589   jresult = (int)result;
77590   return jresult;
77591 }
77592
77593
77594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_BLINK_DURATION_get() {
77595   int jresult ;
77596   int result;
77597
77598   result = (int)Dali::Toolkit::TextField::Property::CURSOR_BLINK_DURATION;
77599   jresult = (int)result;
77600   return jresult;
77601 }
77602
77603
77604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_CURSOR_WIDTH_get() {
77605   int jresult ;
77606   int result;
77607
77608   result = (int)Dali::Toolkit::TextField::Property::CURSOR_WIDTH;
77609   jresult = (int)result;
77610   return jresult;
77611 }
77612
77613
77614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_IMAGE_get() {
77615   int jresult ;
77616   int result;
77617
77618   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_IMAGE;
77619   jresult = (int)result;
77620   return jresult;
77621 }
77622
77623
77624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_GRAB_HANDLE_PRESSED_IMAGE_get() {
77625   int jresult ;
77626   int result;
77627
77628   result = (int)Dali::Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE;
77629   jresult = (int)result;
77630   return jresult;
77631 }
77632
77633
77634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_THRESHOLD_get() {
77635   int jresult ;
77636   int result;
77637
77638   result = (int)Dali::Toolkit::TextField::Property::SCROLL_THRESHOLD;
77639   jresult = (int)result;
77640   return jresult;
77641 }
77642
77643
77644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SCROLL_SPEED_get() {
77645   int jresult ;
77646   int result;
77647
77648   result = (int)Dali::Toolkit::TextField::Property::SCROLL_SPEED;
77649   jresult = (int)result;
77650   return jresult;
77651 }
77652
77653
77654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_LEFT_get() {
77655   int jresult ;
77656   int result;
77657
77658   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT;
77659   jresult = (int)result;
77660   return jresult;
77661 }
77662
77663
77664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_IMAGE_RIGHT_get() {
77665   int jresult ;
77666   int result;
77667
77668   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT;
77669   jresult = (int)result;
77670   return jresult;
77671 }
77672
77673
77674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_LEFT_get() {
77675   int jresult ;
77676   int result;
77677
77678   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT;
77679   jresult = (int)result;
77680   return jresult;
77681 }
77682
77683
77684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT_get() {
77685   int jresult ;
77686   int result;
77687
77688   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT;
77689   jresult = (int)result;
77690   return jresult;
77691 }
77692
77693
77694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_LEFT_get() {
77695   int jresult ;
77696   int result;
77697
77698   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT;
77699   jresult = (int)result;
77700   return jresult;
77701 }
77702
77703
77704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HANDLE_MARKER_IMAGE_RIGHT_get() {
77705   int jresult ;
77706   int result;
77707
77708   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT;
77709   jresult = (int)result;
77710   return jresult;
77711 }
77712
77713
77714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SELECTION_HIGHLIGHT_COLOR_get() {
77715   int jresult ;
77716   int result;
77717
77718   result = (int)Dali::Toolkit::TextField::Property::SELECTION_HIGHLIGHT_COLOR;
77719   jresult = (int)result;
77720   return jresult;
77721 }
77722
77723
77724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_DECORATION_BOUNDING_BOX_get() {
77725   int jresult ;
77726   int result;
77727
77728   result = (int)Dali::Toolkit::TextField::Property::DECORATION_BOUNDING_BOX;
77729   jresult = (int)result;
77730   return jresult;
77731 }
77732
77733
77734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_METHOD_SETTINGS_get() {
77735   int jresult ;
77736   int result;
77737
77738   result = (int)Dali::Toolkit::TextField::Property::INPUT_METHOD_SETTINGS;
77739   jresult = (int)result;
77740   return jresult;
77741 }
77742
77743
77744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_COLOR_get() {
77745   int jresult ;
77746   int result;
77747
77748   result = (int)Dali::Toolkit::TextField::Property::INPUT_COLOR;
77749   jresult = (int)result;
77750   return jresult;
77751 }
77752
77753
77754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_ENABLE_MARKUP_get() {
77755   int jresult ;
77756   int result;
77757
77758   result = (int)Dali::Toolkit::TextField::Property::ENABLE_MARKUP;
77759   jresult = (int)result;
77760   return jresult;
77761 }
77762
77763
77764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_FAMILY_get() {
77765   int jresult ;
77766   int result;
77767
77768   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_FAMILY;
77769   jresult = (int)result;
77770   return jresult;
77771 }
77772
77773
77774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_FONT_STYLE_get() {
77775   int jresult ;
77776   int result;
77777
77778   result = (int)Dali::Toolkit::TextField::Property::INPUT_FONT_STYLE;
77779   jresult = (int)result;
77780   return jresult;
77781 }
77782
77783
77784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_POINT_SIZE_get() {
77785   int jresult ;
77786   int result;
77787
77788   result = (int)Dali::Toolkit::TextField::Property::INPUT_POINT_SIZE;
77789   jresult = (int)result;
77790   return jresult;
77791 }
77792
77793
77794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_UNDERLINE_get() {
77795   int jresult ;
77796   int result;
77797
77798   result = (int)Dali::Toolkit::TextField::Property::UNDERLINE;
77799   jresult = (int)result;
77800   return jresult;
77801 }
77802
77803
77804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_UNDERLINE_get() {
77805   int jresult ;
77806   int result;
77807
77808   result = (int)Dali::Toolkit::TextField::Property::INPUT_UNDERLINE;
77809   jresult = (int)result;
77810   return jresult;
77811 }
77812
77813
77814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_SHADOW_get() {
77815   int jresult ;
77816   int result;
77817
77818   result = (int)Dali::Toolkit::TextField::Property::SHADOW;
77819   jresult = (int)result;
77820   return jresult;
77821 }
77822
77823
77824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_SHADOW_get() {
77825   int jresult ;
77826   int result;
77827
77828   result = (int)Dali::Toolkit::TextField::Property::INPUT_SHADOW;
77829   jresult = (int)result;
77830   return jresult;
77831 }
77832
77833
77834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_EMBOSS_get() {
77835   int jresult ;
77836   int result;
77837
77838   result = (int)Dali::Toolkit::TextField::Property::EMBOSS;
77839   jresult = (int)result;
77840   return jresult;
77841 }
77842
77843
77844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_EMBOSS_get() {
77845   int jresult ;
77846   int result;
77847
77848   result = (int)Dali::Toolkit::TextField::Property::INPUT_EMBOSS;
77849   jresult = (int)result;
77850   return jresult;
77851 }
77852
77853
77854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_OUTLINE_get() {
77855   int jresult ;
77856   int result;
77857
77858   result = (int)Dali::Toolkit::TextField::Property::OUTLINE;
77859   jresult = (int)result;
77860   return jresult;
77861 }
77862
77863
77864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextField_Property_INPUT_OUTLINE_get() {
77865   int jresult ;
77866   int result;
77867
77868   result = (int)Dali::Toolkit::TextField::Property::INPUT_OUTLINE;
77869   jresult = (int)result;
77870   return jresult;
77871 }
77872
77873
77874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_Property() {
77875   void * jresult ;
77876   Dali::Toolkit::TextField::Property *result = 0 ;
77877
77878   {
77879     try {
77880       result = (Dali::Toolkit::TextField::Property *)new Dali::Toolkit::TextField::Property();
77881     } catch (std::out_of_range& e) {
77882       {
77883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77884       };
77885     } catch (std::exception& e) {
77886       {
77887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77888       };
77889     } catch (...) {
77890       {
77891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77892       };
77893     }
77894   }
77895   jresult = (void *)result;
77896   return jresult;
77897 }
77898
77899
77900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_Property(void * jarg1) {
77901   Dali::Toolkit::TextField::Property *arg1 = (Dali::Toolkit::TextField::Property *) 0 ;
77902
77903   arg1 = (Dali::Toolkit::TextField::Property *)jarg1;
77904   {
77905     try {
77906       delete arg1;
77907     } catch (std::out_of_range& e) {
77908       {
77909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77910       };
77911     } catch (std::exception& e) {
77912       {
77913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77914       };
77915     } catch (...) {
77916       {
77917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77918       };
77919     }
77920   }
77921 }
77922
77923
77924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField_InputStyle() {
77925   void * jresult ;
77926   Dali::Toolkit::TextField::InputStyle *result = 0 ;
77927
77928   {
77929     try {
77930       result = (Dali::Toolkit::TextField::InputStyle *)new Dali::Toolkit::TextField::InputStyle();
77931     } catch (std::out_of_range& e) {
77932       {
77933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77934       };
77935     } catch (std::exception& e) {
77936       {
77937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77938       };
77939     } catch (...) {
77940       {
77941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77942       };
77943     }
77944   }
77945   jresult = (void *)result;
77946   return jresult;
77947 }
77948
77949
77950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField_InputStyle(void * jarg1) {
77951   Dali::Toolkit::TextField::InputStyle *arg1 = (Dali::Toolkit::TextField::InputStyle *) 0 ;
77952
77953   arg1 = (Dali::Toolkit::TextField::InputStyle *)jarg1;
77954   {
77955     try {
77956       delete arg1;
77957     } catch (std::out_of_range& e) {
77958       {
77959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77960       };
77961     } catch (std::exception& e) {
77962       {
77963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77964       };
77965     } catch (...) {
77966       {
77967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77968       };
77969     }
77970   }
77971 }
77972
77973
77974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_New() {
77975   void * jresult ;
77976   Dali::Toolkit::TextField result;
77977
77978   {
77979     try {
77980       result = Dali::Toolkit::TextField::New();
77981     } catch (std::out_of_range& e) {
77982       {
77983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77984       };
77985     } catch (std::exception& e) {
77986       {
77987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77988       };
77989     } catch (...) {
77990       {
77991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77992       };
77993     }
77994   }
77995   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
77996   return jresult;
77997 }
77998
77999
78000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_0() {
78001   void * jresult ;
78002   Dali::Toolkit::TextField *result = 0 ;
78003
78004   {
78005     try {
78006       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField();
78007     } catch (std::out_of_range& e) {
78008       {
78009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78010       };
78011     } catch (std::exception& e) {
78012       {
78013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78014       };
78015     } catch (...) {
78016       {
78017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78018       };
78019     }
78020   }
78021   jresult = (void *)result;
78022   return jresult;
78023 }
78024
78025
78026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextField__SWIG_1(void * jarg1) {
78027   void * jresult ;
78028   Dali::Toolkit::TextField *arg1 = 0 ;
78029   Dali::Toolkit::TextField *result = 0 ;
78030
78031   arg1 = (Dali::Toolkit::TextField *)jarg1;
78032   if (!arg1) {
78033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78034     return 0;
78035   }
78036   {
78037     try {
78038       result = (Dali::Toolkit::TextField *)new Dali::Toolkit::TextField((Dali::Toolkit::TextField const &)*arg1);
78039     } catch (std::out_of_range& e) {
78040       {
78041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78042       };
78043     } catch (std::exception& e) {
78044       {
78045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78046       };
78047     } catch (...) {
78048       {
78049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78050       };
78051     }
78052   }
78053   jresult = (void *)result;
78054   return jresult;
78055 }
78056
78057
78058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_Assign(void * jarg1, void * jarg2) {
78059   void * jresult ;
78060   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78061   Dali::Toolkit::TextField *arg2 = 0 ;
78062   Dali::Toolkit::TextField *result = 0 ;
78063
78064   arg1 = (Dali::Toolkit::TextField *)jarg1;
78065   arg2 = (Dali::Toolkit::TextField *)jarg2;
78066   if (!arg2) {
78067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextField const & type is null", 0);
78068     return 0;
78069   }
78070   {
78071     try {
78072       result = (Dali::Toolkit::TextField *) &(arg1)->operator =((Dali::Toolkit::TextField const &)*arg2);
78073     } catch (std::out_of_range& e) {
78074       {
78075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78076       };
78077     } catch (std::exception& e) {
78078       {
78079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78080       };
78081     } catch (...) {
78082       {
78083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78084       };
78085     }
78086   }
78087   jresult = (void *)result;
78088   return jresult;
78089 }
78090
78091
78092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextField(void * jarg1) {
78093   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78094
78095   arg1 = (Dali::Toolkit::TextField *)jarg1;
78096   {
78097     try {
78098       delete arg1;
78099     } catch (std::out_of_range& e) {
78100       {
78101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78102       };
78103     } catch (std::exception& e) {
78104       {
78105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78106       };
78107     } catch (...) {
78108       {
78109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78110       };
78111     }
78112   }
78113 }
78114
78115
78116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_DownCast(void * jarg1) {
78117   void * jresult ;
78118   Dali::BaseHandle arg1 ;
78119   Dali::BaseHandle *argp1 ;
78120   Dali::Toolkit::TextField result;
78121
78122   argp1 = (Dali::BaseHandle *)jarg1;
78123   if (!argp1) {
78124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78125     return 0;
78126   }
78127   arg1 = *argp1;
78128   {
78129     try {
78130       result = Dali::Toolkit::TextField::DownCast(arg1);
78131     } catch (std::out_of_range& e) {
78132       {
78133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78134       };
78135     } catch (std::exception& e) {
78136       {
78137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78138       };
78139     } catch (...) {
78140       {
78141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78142       };
78143     }
78144   }
78145   jresult = new Dali::Toolkit::TextField((const Dali::Toolkit::TextField &)result);
78146   return jresult;
78147 }
78148
78149
78150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_TextChangedSignal(void * jarg1) {
78151   void * jresult ;
78152   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78153   Dali::Toolkit::TextField::TextChangedSignalType *result = 0 ;
78154
78155   arg1 = (Dali::Toolkit::TextField *)jarg1;
78156   {
78157     try {
78158       result = (Dali::Toolkit::TextField::TextChangedSignalType *) &(arg1)->TextChangedSignal();
78159     } catch (std::out_of_range& e) {
78160       {
78161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78162       };
78163     } catch (std::exception& e) {
78164       {
78165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78166       };
78167     } catch (...) {
78168       {
78169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78170       };
78171     }
78172   }
78173   jresult = (void *)result;
78174   return jresult;
78175 }
78176
78177
78178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_MaxLengthReachedSignal(void * jarg1) {
78179   void * jresult ;
78180   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78181   Dali::Toolkit::TextField::MaxLengthReachedSignalType *result = 0 ;
78182
78183   arg1 = (Dali::Toolkit::TextField *)jarg1;
78184   {
78185     try {
78186       result = (Dali::Toolkit::TextField::MaxLengthReachedSignalType *) &(arg1)->MaxLengthReachedSignal();
78187     } catch (std::out_of_range& e) {
78188       {
78189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78190       };
78191     } catch (std::exception& e) {
78192       {
78193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78194       };
78195     } catch (...) {
78196       {
78197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78198       };
78199     }
78200   }
78201   jresult = (void *)result;
78202   return jresult;
78203 }
78204
78205
78206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextField_InputStyleChangedSignal(void * jarg1) {
78207   void * jresult ;
78208   Dali::Toolkit::TextField *arg1 = (Dali::Toolkit::TextField *) 0 ;
78209   Dali::Toolkit::TextField::InputStyleChangedSignalType *result = 0 ;
78210
78211   arg1 = (Dali::Toolkit::TextField *)jarg1;
78212   {
78213     try {
78214       result = (Dali::Toolkit::TextField::InputStyleChangedSignalType *) &(arg1)->InputStyleChangedSignal();
78215     } catch (std::out_of_range& e) {
78216       {
78217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78218       };
78219     } catch (std::exception& e) {
78220       {
78221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78222       };
78223     } catch (...) {
78224       {
78225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78226       };
78227     }
78228   }
78229   jresult = (void *)result;
78230   return jresult;
78231 }
78232
78233
78234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
78235   int jresult ;
78236   int result;
78237
78238   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
78239   jresult = (int)result;
78240   return jresult;
78241 }
78242
78243
78244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78245   int jresult ;
78246   int result;
78247
78248   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78249   jresult = (int)result;
78250   return jresult;
78251 }
78252
78253
78254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78255   int jresult ;
78256   int result;
78257
78258   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78259   jresult = (int)result;
78260   return jresult;
78261 }
78262
78263
78264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78265   int jresult ;
78266   int result;
78267
78268   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78269   jresult = (int)result;
78270   return jresult;
78271 }
78272
78273
78274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78275   int jresult ;
78276   int result;
78277
78278   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78279   jresult = (int)result;
78280   return jresult;
78281 }
78282
78283
78284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78285   int jresult ;
78286   int result;
78287
78288   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78289   jresult = (int)result;
78290   return jresult;
78291 }
78292
78293
78294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78295   int jresult ;
78296   int result;
78297
78298   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78299   jresult = (int)result;
78300   return jresult;
78301 }
78302
78303
78304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78305   int jresult ;
78306   int result;
78307
78308   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78309   jresult = (int)result;
78310   return jresult;
78311 }
78312
78313
78314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78315   int jresult ;
78316   int result;
78317
78318   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78319   jresult = (int)result;
78320   return jresult;
78321 }
78322
78323
78324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
78325   int jresult ;
78326   int result;
78327
78328   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
78329   jresult = (int)result;
78330   return jresult;
78331 }
78332
78333
78334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
78335   int jresult ;
78336   int result;
78337
78338   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
78339   jresult = (int)result;
78340   return jresult;
78341 }
78342
78343
78344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
78345   int jresult ;
78346   int result;
78347
78348   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
78349   jresult = (int)result;
78350   return jresult;
78351 }
78352
78353
78354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
78355   int jresult ;
78356   int result;
78357
78358   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
78359   jresult = (int)result;
78360   return jresult;
78361 }
78362
78363
78364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
78365   int jresult ;
78366   int result;
78367
78368   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
78369   jresult = (int)result;
78370   return jresult;
78371 }
78372
78373
78374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78375   int jresult ;
78376   int result;
78377
78378   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78379   jresult = (int)result;
78380   return jresult;
78381 }
78382
78383
78384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78385   int jresult ;
78386   int result;
78387
78388   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78389   jresult = (int)result;
78390   return jresult;
78391 }
78392
78393
78394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78395   int jresult ;
78396   int result;
78397
78398   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78399   jresult = (int)result;
78400   return jresult;
78401 }
78402
78403
78404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78405   int jresult ;
78406   int result;
78407
78408   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78409   jresult = (int)result;
78410   return jresult;
78411 }
78412
78413
78414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78415   int jresult ;
78416   int result;
78417
78418   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78419   jresult = (int)result;
78420   return jresult;
78421 }
78422
78423
78424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78425   int jresult ;
78426   int result;
78427
78428   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78429   jresult = (int)result;
78430   return jresult;
78431 }
78432
78433
78434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78435   int jresult ;
78436   int result;
78437
78438   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78439   jresult = (int)result;
78440   return jresult;
78441 }
78442
78443
78444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78445   int jresult ;
78446   int result;
78447
78448   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78449   jresult = (int)result;
78450   return jresult;
78451 }
78452
78453
78454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78455   int jresult ;
78456   int result;
78457
78458   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78459   jresult = (int)result;
78460   return jresult;
78461 }
78462
78463
78464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78465   int jresult ;
78466   int result;
78467
78468   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78469   jresult = (int)result;
78470   return jresult;
78471 }
78472
78473
78474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78475   void * jresult ;
78476   Dali::Toolkit::TextLabel::Property *result = 0 ;
78477
78478   {
78479     try {
78480       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78481     } catch (std::out_of_range& e) {
78482       {
78483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78484       };
78485     } catch (std::exception& e) {
78486       {
78487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78488       };
78489     } catch (...) {
78490       {
78491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78492       };
78493     }
78494   }
78495   jresult = (void *)result;
78496   return jresult;
78497 }
78498
78499
78500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78501   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78502
78503   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78504   {
78505     try {
78506       delete arg1;
78507     } catch (std::out_of_range& e) {
78508       {
78509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78510       };
78511     } catch (std::exception& e) {
78512       {
78513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78514       };
78515     } catch (...) {
78516       {
78517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78518       };
78519     }
78520   }
78521 }
78522
78523
78524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78525   void * jresult ;
78526   Dali::Toolkit::TextLabel result;
78527
78528   {
78529     try {
78530       result = Dali::Toolkit::TextLabel::New();
78531     } catch (std::out_of_range& e) {
78532       {
78533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78534       };
78535     } catch (std::exception& e) {
78536       {
78537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78538       };
78539     } catch (...) {
78540       {
78541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78542       };
78543     }
78544   }
78545   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78546   return jresult;
78547 }
78548
78549
78550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78551   void * jresult ;
78552   std::string *arg1 = 0 ;
78553   Dali::Toolkit::TextLabel result;
78554
78555   if (!jarg1) {
78556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78557     return 0;
78558   }
78559   std::string arg1_str(jarg1);
78560   arg1 = &arg1_str;
78561   {
78562     try {
78563       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78564     } catch (std::out_of_range& e) {
78565       {
78566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78567       };
78568     } catch (std::exception& e) {
78569       {
78570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78571       };
78572     } catch (...) {
78573       {
78574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78575       };
78576     }
78577   }
78578   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78579
78580   //argout typemap for const std::string&
78581
78582   return jresult;
78583 }
78584
78585
78586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78587   void * jresult ;
78588   Dali::Toolkit::TextLabel *result = 0 ;
78589
78590   {
78591     try {
78592       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78593     } catch (std::out_of_range& e) {
78594       {
78595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78596       };
78597     } catch (std::exception& e) {
78598       {
78599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78600       };
78601     } catch (...) {
78602       {
78603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78604       };
78605     }
78606   }
78607   jresult = (void *)result;
78608   return jresult;
78609 }
78610
78611
78612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78613   void * jresult ;
78614   Dali::Toolkit::TextLabel *arg1 = 0 ;
78615   Dali::Toolkit::TextLabel *result = 0 ;
78616
78617   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78618   if (!arg1) {
78619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78620     return 0;
78621   }
78622   {
78623     try {
78624       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78625     } catch (std::out_of_range& e) {
78626       {
78627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78628       };
78629     } catch (std::exception& e) {
78630       {
78631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78632       };
78633     } catch (...) {
78634       {
78635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78636       };
78637     }
78638   }
78639   jresult = (void *)result;
78640   return jresult;
78641 }
78642
78643
78644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78645   void * jresult ;
78646   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78647   Dali::Toolkit::TextLabel *arg2 = 0 ;
78648   Dali::Toolkit::TextLabel *result = 0 ;
78649
78650   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78651   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78652   if (!arg2) {
78653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78654     return 0;
78655   }
78656   {
78657     try {
78658       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78659     } catch (std::out_of_range& e) {
78660       {
78661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78662       };
78663     } catch (std::exception& e) {
78664       {
78665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78666       };
78667     } catch (...) {
78668       {
78669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78670       };
78671     }
78672   }
78673   jresult = (void *)result;
78674   return jresult;
78675 }
78676
78677
78678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78679   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78680
78681   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78682   {
78683     try {
78684       delete arg1;
78685     } catch (std::out_of_range& e) {
78686       {
78687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78688       };
78689     } catch (std::exception& e) {
78690       {
78691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78692       };
78693     } catch (...) {
78694       {
78695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78696       };
78697     }
78698   }
78699 }
78700
78701
78702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78703   void * jresult ;
78704   Dali::BaseHandle arg1 ;
78705   Dali::BaseHandle *argp1 ;
78706   Dali::Toolkit::TextLabel result;
78707
78708   argp1 = (Dali::BaseHandle *)jarg1;
78709   if (!argp1) {
78710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78711     return 0;
78712   }
78713   arg1 = *argp1;
78714   {
78715     try {
78716       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78717     } catch (std::out_of_range& e) {
78718       {
78719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78720       };
78721     } catch (std::exception& e) {
78722       {
78723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78724       };
78725     } catch (...) {
78726       {
78727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78728       };
78729     }
78730   }
78731   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78732   return jresult;
78733 }
78734
78735
78736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78737   void * jresult ;
78738   Dali::Toolkit::AccessibilityManager *result = 0 ;
78739
78740   {
78741     try {
78742       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78743     } catch (std::out_of_range& e) {
78744       {
78745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78746       };
78747     } catch (std::exception& e) {
78748       {
78749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78750       };
78751     } catch (...) {
78752       {
78753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78754       };
78755     }
78756   }
78757   jresult = (void *)result;
78758   return jresult;
78759 }
78760
78761
78762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78763   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78764
78765   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78766   {
78767     try {
78768       delete arg1;
78769     } catch (std::out_of_range& e) {
78770       {
78771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78772       };
78773     } catch (std::exception& e) {
78774       {
78775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78776       };
78777     } catch (...) {
78778       {
78779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78780       };
78781     }
78782   }
78783 }
78784
78785
78786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78787   void * jresult ;
78788   Dali::Toolkit::AccessibilityManager result;
78789
78790   {
78791     try {
78792       result = Dali::Toolkit::AccessibilityManager::Get();
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 = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78808   return jresult;
78809 }
78810
78811
78812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78813   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78814   Dali::Actor arg2 ;
78815   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78816   std::string *arg4 = 0 ;
78817   Dali::Actor *argp2 ;
78818
78819   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78820   argp2 = (Dali::Actor *)jarg2;
78821   if (!argp2) {
78822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78823     return ;
78824   }
78825   arg2 = *argp2;
78826   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78827   if (!jarg4) {
78828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78829     return ;
78830   }
78831   std::string arg4_str(jarg4);
78832   arg4 = &arg4_str;
78833   {
78834     try {
78835       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
78836     } catch (std::out_of_range& e) {
78837       {
78838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78839       };
78840     } catch (std::exception& e) {
78841       {
78842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78843       };
78844     } catch (...) {
78845       {
78846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78847       };
78848     }
78849   }
78850
78851   //argout typemap for const std::string&
78852
78853 }
78854
78855
78856 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
78857   char * jresult ;
78858   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78859   Dali::Actor arg2 ;
78860   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78861   Dali::Actor *argp2 ;
78862   std::string result;
78863
78864   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78865   argp2 = (Dali::Actor *)jarg2;
78866   if (!argp2) {
78867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78868     return 0;
78869   }
78870   arg2 = *argp2;
78871   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78872   {
78873     try {
78874       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
78875     } catch (std::out_of_range& e) {
78876       {
78877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78878       };
78879     } catch (std::exception& e) {
78880       {
78881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78882       };
78883     } catch (...) {
78884       {
78885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78886       };
78887     }
78888   }
78889   jresult = SWIG_csharp_string_callback((&result)->c_str());
78890   return jresult;
78891 }
78892
78893
78894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
78895   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78896   Dali::Actor arg2 ;
78897   unsigned int arg3 ;
78898   Dali::Actor *argp2 ;
78899
78900   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78901   argp2 = (Dali::Actor *)jarg2;
78902   if (!argp2) {
78903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78904     return ;
78905   }
78906   arg2 = *argp2;
78907   arg3 = (unsigned int)jarg3;
78908   {
78909     try {
78910       (arg1)->SetFocusOrder(arg2,arg3);
78911     } catch (std::out_of_range& e) {
78912       {
78913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78914       };
78915     } catch (std::exception& e) {
78916       {
78917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78918       };
78919     } catch (...) {
78920       {
78921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78922       };
78923     }
78924   }
78925 }
78926
78927
78928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
78929   unsigned int jresult ;
78930   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78931   Dali::Actor arg2 ;
78932   Dali::Actor *argp2 ;
78933   unsigned int result;
78934
78935   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78936   argp2 = (Dali::Actor *)jarg2;
78937   if (!argp2) {
78938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78939     return 0;
78940   }
78941   arg2 = *argp2;
78942   {
78943     try {
78944       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
78945     } catch (std::out_of_range& e) {
78946       {
78947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78948       };
78949     } catch (std::exception& e) {
78950       {
78951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78952       };
78953     } catch (...) {
78954       {
78955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78956       };
78957     }
78958   }
78959   jresult = result;
78960   return jresult;
78961 }
78962
78963
78964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
78965   unsigned int jresult ;
78966   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78967   unsigned int result;
78968
78969   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78970   {
78971     try {
78972       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
78973     } catch (std::out_of_range& e) {
78974       {
78975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78976       };
78977     } catch (std::exception& e) {
78978       {
78979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78980       };
78981     } catch (...) {
78982       {
78983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78984       };
78985     }
78986   }
78987   jresult = result;
78988   return jresult;
78989 }
78990
78991
78992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
78993   void * jresult ;
78994   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78995   unsigned int arg2 ;
78996   Dali::Actor result;
78997
78998   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78999   arg2 = (unsigned int)jarg2;
79000   {
79001     try {
79002       result = (arg1)->GetActorByFocusOrder(arg2);
79003     } catch (std::out_of_range& e) {
79004       {
79005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79006       };
79007     } catch (std::exception& e) {
79008       {
79009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79010       };
79011     } catch (...) {
79012       {
79013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79014       };
79015     }
79016   }
79017   jresult = new Dali::Actor((const Dali::Actor &)result);
79018   return jresult;
79019 }
79020
79021
79022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79023   unsigned int jresult ;
79024   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79025   Dali::Actor arg2 ;
79026   Dali::Actor *argp2 ;
79027   bool result;
79028
79029   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79030   argp2 = (Dali::Actor *)jarg2;
79031   if (!argp2) {
79032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79033     return 0;
79034   }
79035   arg2 = *argp2;
79036   {
79037     try {
79038       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79039     } catch (std::out_of_range& e) {
79040       {
79041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79042       };
79043     } catch (std::exception& e) {
79044       {
79045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79046       };
79047     } catch (...) {
79048       {
79049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79050       };
79051     }
79052   }
79053   jresult = result;
79054   return jresult;
79055 }
79056
79057
79058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79059   void * jresult ;
79060   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79061   Dali::Actor result;
79062
79063   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79064   {
79065     try {
79066       result = (arg1)->GetCurrentFocusActor();
79067     } catch (std::out_of_range& e) {
79068       {
79069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79070       };
79071     } catch (std::exception& e) {
79072       {
79073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79074       };
79075     } catch (...) {
79076       {
79077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79078       };
79079     }
79080   }
79081   jresult = new Dali::Actor((const Dali::Actor &)result);
79082   return jresult;
79083 }
79084
79085
79086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79087   void * jresult ;
79088   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79089   Dali::Actor result;
79090
79091   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79092   {
79093     try {
79094       result = (arg1)->GetCurrentFocusGroup();
79095     } catch (std::out_of_range& e) {
79096       {
79097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79098       };
79099     } catch (std::exception& e) {
79100       {
79101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79102       };
79103     } catch (...) {
79104       {
79105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79106       };
79107     }
79108   }
79109   jresult = new Dali::Actor((const Dali::Actor &)result);
79110   return jresult;
79111 }
79112
79113
79114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79115   unsigned int jresult ;
79116   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79117   unsigned int result;
79118
79119   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79120   {
79121     try {
79122       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79123     } catch (std::out_of_range& e) {
79124       {
79125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79126       };
79127     } catch (std::exception& e) {
79128       {
79129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79130       };
79131     } catch (...) {
79132       {
79133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79134       };
79135     }
79136   }
79137   jresult = result;
79138   return jresult;
79139 }
79140
79141
79142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79143   unsigned int jresult ;
79144   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79145   bool result;
79146
79147   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79148   {
79149     try {
79150       result = (bool)(arg1)->MoveFocusForward();
79151     } catch (std::out_of_range& e) {
79152       {
79153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79154       };
79155     } catch (std::exception& e) {
79156       {
79157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79158       };
79159     } catch (...) {
79160       {
79161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79162       };
79163     }
79164   }
79165   jresult = result;
79166   return jresult;
79167 }
79168
79169
79170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79171   unsigned int jresult ;
79172   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79173   bool result;
79174
79175   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79176   {
79177     try {
79178       result = (bool)(arg1)->MoveFocusBackward();
79179     } catch (std::out_of_range& e) {
79180       {
79181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79182       };
79183     } catch (std::exception& e) {
79184       {
79185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79186       };
79187     } catch (...) {
79188       {
79189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79190       };
79191     }
79192   }
79193   jresult = result;
79194   return jresult;
79195 }
79196
79197
79198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79199   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79200
79201   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79202   {
79203     try {
79204       (arg1)->ClearFocus();
79205     } catch (std::out_of_range& e) {
79206       {
79207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79208       };
79209     } catch (std::exception& e) {
79210       {
79211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79212       };
79213     } catch (...) {
79214       {
79215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79216       };
79217     }
79218   }
79219 }
79220
79221
79222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79223   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79224
79225   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79226   {
79227     try {
79228       (arg1)->Reset();
79229     } catch (std::out_of_range& e) {
79230       {
79231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79232       };
79233     } catch (std::exception& e) {
79234       {
79235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79236       };
79237     } catch (...) {
79238       {
79239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79240       };
79241     }
79242   }
79243 }
79244
79245
79246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79247   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79248   Dali::Actor arg2 ;
79249   bool arg3 ;
79250   Dali::Actor *argp2 ;
79251
79252   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79253   argp2 = (Dali::Actor *)jarg2;
79254   if (!argp2) {
79255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79256     return ;
79257   }
79258   arg2 = *argp2;
79259   arg3 = jarg3 ? true : false;
79260   {
79261     try {
79262       (arg1)->SetFocusGroup(arg2,arg3);
79263     } catch (std::out_of_range& e) {
79264       {
79265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79266       };
79267     } catch (std::exception& e) {
79268       {
79269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79270       };
79271     } catch (...) {
79272       {
79273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79274       };
79275     }
79276   }
79277 }
79278
79279
79280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79281   unsigned int jresult ;
79282   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79283   Dali::Actor arg2 ;
79284   Dali::Actor *argp2 ;
79285   bool result;
79286
79287   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79288   argp2 = (Dali::Actor *)jarg2;
79289   if (!argp2) {
79290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79291     return 0;
79292   }
79293   arg2 = *argp2;
79294   {
79295     try {
79296       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79297     } catch (std::out_of_range& e) {
79298       {
79299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79300       };
79301     } catch (std::exception& e) {
79302       {
79303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79304       };
79305     } catch (...) {
79306       {
79307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79308       };
79309     }
79310   }
79311   jresult = result;
79312   return jresult;
79313 }
79314
79315
79316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79317   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79318   bool arg2 ;
79319
79320   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79321   arg2 = jarg2 ? true : false;
79322   {
79323     try {
79324       (arg1)->SetGroupMode(arg2);
79325     } catch (std::out_of_range& e) {
79326       {
79327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79328       };
79329     } catch (std::exception& e) {
79330       {
79331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79332       };
79333     } catch (...) {
79334       {
79335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79336       };
79337     }
79338   }
79339 }
79340
79341
79342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79343   unsigned int jresult ;
79344   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79345   bool result;
79346
79347   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79348   {
79349     try {
79350       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79351     } catch (std::out_of_range& e) {
79352       {
79353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79354       };
79355     } catch (std::exception& e) {
79356       {
79357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79358       };
79359     } catch (...) {
79360       {
79361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79362       };
79363     }
79364   }
79365   jresult = result;
79366   return jresult;
79367 }
79368
79369
79370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79371   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79372   bool arg2 ;
79373
79374   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79375   arg2 = jarg2 ? true : false;
79376   {
79377     try {
79378       (arg1)->SetWrapMode(arg2);
79379     } catch (std::out_of_range& e) {
79380       {
79381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79382       };
79383     } catch (std::exception& e) {
79384       {
79385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79386       };
79387     } catch (...) {
79388       {
79389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79390       };
79391     }
79392   }
79393 }
79394
79395
79396 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79397   unsigned int jresult ;
79398   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79399   bool result;
79400
79401   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79402   {
79403     try {
79404       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79405     } catch (std::out_of_range& e) {
79406       {
79407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79408       };
79409     } catch (std::exception& e) {
79410       {
79411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79412       };
79413     } catch (...) {
79414       {
79415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79416       };
79417     }
79418   }
79419   jresult = result;
79420   return jresult;
79421 }
79422
79423
79424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79425   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79426   Dali::Actor arg2 ;
79427   Dali::Actor *argp2 ;
79428
79429   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79430   argp2 = (Dali::Actor *)jarg2;
79431   if (!argp2) {
79432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79433     return ;
79434   }
79435   arg2 = *argp2;
79436   {
79437     try {
79438       (arg1)->SetFocusIndicatorActor(arg2);
79439     } catch (std::out_of_range& e) {
79440       {
79441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79442       };
79443     } catch (std::exception& e) {
79444       {
79445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79446       };
79447     } catch (...) {
79448       {
79449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79450       };
79451     }
79452   }
79453 }
79454
79455
79456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79457   void * jresult ;
79458   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79459   Dali::Actor result;
79460
79461   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79462   {
79463     try {
79464       result = (arg1)->GetFocusIndicatorActor();
79465     } catch (std::out_of_range& e) {
79466       {
79467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79468       };
79469     } catch (std::exception& e) {
79470       {
79471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79472       };
79473     } catch (...) {
79474       {
79475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79476       };
79477     }
79478   }
79479   jresult = new Dali::Actor((const Dali::Actor &)result);
79480   return jresult;
79481 }
79482
79483
79484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79485   void * jresult ;
79486   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79487   Dali::Actor arg2 ;
79488   Dali::Actor *argp2 ;
79489   Dali::Actor result;
79490
79491   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79492   argp2 = (Dali::Actor *)jarg2;
79493   if (!argp2) {
79494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79495     return 0;
79496   }
79497   arg2 = *argp2;
79498   {
79499     try {
79500       result = (arg1)->GetFocusGroup(arg2);
79501     } catch (std::out_of_range& e) {
79502       {
79503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79504       };
79505     } catch (std::exception& e) {
79506       {
79507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79508       };
79509     } catch (...) {
79510       {
79511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79512       };
79513     }
79514   }
79515   jresult = new Dali::Actor((const Dali::Actor &)result);
79516   return jresult;
79517 }
79518
79519
79520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79521   void * jresult ;
79522   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79523   Dali::Vector2 result;
79524
79525   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79526   {
79527     try {
79528       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79529     } catch (std::out_of_range& e) {
79530       {
79531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79532       };
79533     } catch (std::exception& e) {
79534       {
79535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79536       };
79537     } catch (...) {
79538       {
79539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79540       };
79541     }
79542   }
79543   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79544   return jresult;
79545 }
79546
79547
79548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79549   void * jresult ;
79550   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79551   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79552
79553   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79554   {
79555     try {
79556       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79557     } catch (std::out_of_range& e) {
79558       {
79559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79560       };
79561     } catch (std::exception& e) {
79562       {
79563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79564       };
79565     } catch (...) {
79566       {
79567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79568       };
79569     }
79570   }
79571   jresult = (void *)result;
79572   return jresult;
79573 }
79574
79575
79576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79577   void * jresult ;
79578   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79579   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79580
79581   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79582   {
79583     try {
79584       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79585     } catch (std::out_of_range& e) {
79586       {
79587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79588       };
79589     } catch (std::exception& e) {
79590       {
79591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79592       };
79593     } catch (...) {
79594       {
79595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79596       };
79597     }
79598   }
79599   jresult = (void *)result;
79600   return jresult;
79601 }
79602
79603
79604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79605   void * jresult ;
79606   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79607   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79608
79609   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79610   {
79611     try {
79612       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79613     } catch (std::out_of_range& e) {
79614       {
79615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79616       };
79617     } catch (std::exception& e) {
79618       {
79619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79620       };
79621     } catch (...) {
79622       {
79623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79624       };
79625     }
79626   }
79627   jresult = (void *)result;
79628   return jresult;
79629 }
79630
79631
79632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79633   void * jresult ;
79634   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79635   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79636
79637   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79638   {
79639     try {
79640       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79641     } catch (std::out_of_range& e) {
79642       {
79643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79644       };
79645     } catch (std::exception& e) {
79646       {
79647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79648       };
79649     } catch (...) {
79650       {
79651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79652       };
79653     }
79654   }
79655   jresult = (void *)result;
79656   return jresult;
79657 }
79658
79659
79660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79661   void * jresult ;
79662   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79663   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79664
79665   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79666   {
79667     try {
79668       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79669     } catch (std::out_of_range& e) {
79670       {
79671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79672       };
79673     } catch (std::exception& e) {
79674       {
79675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79676       };
79677     } catch (...) {
79678       {
79679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79680       };
79681     }
79682   }
79683   jresult = (void *)result;
79684   return jresult;
79685 }
79686
79687
79688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79689   void * jresult ;
79690   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79691   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79692
79693   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79694   {
79695     try {
79696       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79697     } catch (std::out_of_range& e) {
79698       {
79699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79700       };
79701     } catch (std::exception& e) {
79702       {
79703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79704       };
79705     } catch (...) {
79706       {
79707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79708       };
79709     }
79710   }
79711   jresult = (void *)result;
79712   return jresult;
79713 }
79714
79715
79716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79717   void * jresult ;
79718   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79719   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79720
79721   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79722   {
79723     try {
79724       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79725     } catch (std::out_of_range& e) {
79726       {
79727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79728       };
79729     } catch (std::exception& e) {
79730       {
79731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79732       };
79733     } catch (...) {
79734       {
79735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79736       };
79737     }
79738   }
79739   jresult = (void *)result;
79740   return jresult;
79741 }
79742
79743
79744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
79745   void * jresult ;
79746   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79747   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79748
79749   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79750   {
79751     try {
79752       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
79753     } catch (std::out_of_range& e) {
79754       {
79755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79756       };
79757     } catch (std::exception& e) {
79758       {
79759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79760       };
79761     } catch (...) {
79762       {
79763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79764       };
79765     }
79766   }
79767   jresult = (void *)result;
79768   return jresult;
79769 }
79770
79771
79772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
79773   void * jresult ;
79774   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79775   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79776
79777   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79778   {
79779     try {
79780       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
79781     } catch (std::out_of_range& e) {
79782       {
79783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79784       };
79785     } catch (std::exception& e) {
79786       {
79787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79788       };
79789     } catch (...) {
79790       {
79791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79792       };
79793     }
79794   }
79795   jresult = (void *)result;
79796   return jresult;
79797 }
79798
79799
79800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
79801   void * jresult ;
79802   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79803   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79804
79805   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79806   {
79807     try {
79808       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
79809     } catch (std::out_of_range& e) {
79810       {
79811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79812       };
79813     } catch (std::exception& e) {
79814       {
79815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79816       };
79817     } catch (...) {
79818       {
79819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79820       };
79821     }
79822   }
79823   jresult = (void *)result;
79824   return jresult;
79825 }
79826
79827
79828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
79829   void * jresult ;
79830   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79831   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79832
79833   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79834   {
79835     try {
79836       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
79837     } catch (std::out_of_range& e) {
79838       {
79839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79840       };
79841     } catch (std::exception& e) {
79842       {
79843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79844       };
79845     } catch (...) {
79846       {
79847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79848       };
79849     }
79850   }
79851   jresult = (void *)result;
79852   return jresult;
79853 }
79854
79855
79856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
79857   void * jresult ;
79858   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79859   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79860
79861   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79862   {
79863     try {
79864       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
79865     } catch (std::out_of_range& e) {
79866       {
79867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79868       };
79869     } catch (std::exception& e) {
79870       {
79871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79872       };
79873     } catch (...) {
79874       {
79875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79876       };
79877     }
79878   }
79879   jresult = (void *)result;
79880   return jresult;
79881 }
79882
79883
79884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
79885   void * jresult ;
79886   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79887   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79888
79889   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79890   {
79891     try {
79892       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
79893     } catch (std::out_of_range& e) {
79894       {
79895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79896       };
79897     } catch (std::exception& e) {
79898       {
79899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79900       };
79901     } catch (...) {
79902       {
79903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79904       };
79905     }
79906   }
79907   jresult = (void *)result;
79908   return jresult;
79909 }
79910
79911
79912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
79913   void * jresult ;
79914   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79915   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79916
79917   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79918   {
79919     try {
79920       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
79921     } catch (std::out_of_range& e) {
79922       {
79923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79924       };
79925     } catch (std::exception& e) {
79926       {
79927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79928       };
79929     } catch (...) {
79930       {
79931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79932       };
79933     }
79934   }
79935   jresult = (void *)result;
79936   return jresult;
79937 }
79938
79939
79940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
79941   void * jresult ;
79942   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79943   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79944
79945   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79946   {
79947     try {
79948       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
79949     } catch (std::out_of_range& e) {
79950       {
79951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79952       };
79953     } catch (std::exception& e) {
79954       {
79955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79956       };
79957     } catch (...) {
79958       {
79959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79960       };
79961     }
79962   }
79963   jresult = (void *)result;
79964   return jresult;
79965 }
79966
79967
79968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
79969   void * jresult ;
79970   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79971   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79972
79973   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79974   {
79975     try {
79976       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
79977     } catch (std::out_of_range& e) {
79978       {
79979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79980       };
79981     } catch (std::exception& e) {
79982       {
79983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79984       };
79985     } catch (...) {
79986       {
79987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79988       };
79989     }
79990   }
79991   jresult = (void *)result;
79992   return jresult;
79993 }
79994
79995
79996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
79997   void * jresult ;
79998   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79999   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80000
80001   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80002   {
80003     try {
80004       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80005     } catch (std::out_of_range& e) {
80006       {
80007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80008       };
80009     } catch (std::exception& e) {
80010       {
80011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80012       };
80013     } catch (...) {
80014       {
80015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80016       };
80017     }
80018   }
80019   jresult = (void *)result;
80020   return jresult;
80021 }
80022
80023
80024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80025   void * jresult ;
80026   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80027   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80028
80029   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80030   {
80031     try {
80032       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80033     } catch (std::out_of_range& e) {
80034       {
80035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80036       };
80037     } catch (std::exception& e) {
80038       {
80039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80040       };
80041     } catch (...) {
80042       {
80043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80044       };
80045     }
80046   }
80047   jresult = (void *)result;
80048   return jresult;
80049 }
80050
80051
80052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80053   void * jresult ;
80054   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80055   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80056
80057   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80058   {
80059     try {
80060       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80061     } catch (std::out_of_range& e) {
80062       {
80063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80064       };
80065     } catch (std::exception& e) {
80066       {
80067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80068       };
80069     } catch (...) {
80070       {
80071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80072       };
80073     }
80074   }
80075   jresult = (void *)result;
80076   return jresult;
80077 }
80078
80079
80080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80081   void * jresult ;
80082   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80083   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80084
80085   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80086   {
80087     try {
80088       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80089     } catch (std::out_of_range& e) {
80090       {
80091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80092       };
80093     } catch (std::exception& e) {
80094       {
80095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80096       };
80097     } catch (...) {
80098       {
80099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80100       };
80101     }
80102   }
80103   jresult = (void *)result;
80104   return jresult;
80105 }
80106
80107
80108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80109   void * jresult ;
80110   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80111   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80112
80113   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80114   {
80115     try {
80116       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80117     } catch (std::out_of_range& e) {
80118       {
80119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80120       };
80121     } catch (std::exception& e) {
80122       {
80123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80124       };
80125     } catch (...) {
80126       {
80127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80128       };
80129     }
80130   }
80131   jresult = (void *)result;
80132   return jresult;
80133 }
80134
80135
80136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80137   void * jresult ;
80138   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80139   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80140
80141   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80142   {
80143     try {
80144       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80145     } catch (std::out_of_range& e) {
80146       {
80147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80148       };
80149     } catch (std::exception& e) {
80150       {
80151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80152       };
80153     } catch (...) {
80154       {
80155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80156       };
80157     }
80158   }
80159   jresult = (void *)result;
80160   return jresult;
80161 }
80162
80163
80164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80165   void * jresult ;
80166   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80167   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80168
80169   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80170   {
80171     try {
80172       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80173     } catch (std::out_of_range& e) {
80174       {
80175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80176       };
80177     } catch (std::exception& e) {
80178       {
80179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80180       };
80181     } catch (...) {
80182       {
80183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80184       };
80185     }
80186   }
80187   jresult = (void *)result;
80188   return jresult;
80189 }
80190
80191
80192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80193   void * jresult ;
80194   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80195   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80196
80197   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80198   {
80199     try {
80200       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80201     } catch (std::out_of_range& e) {
80202       {
80203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80204       };
80205     } catch (std::exception& e) {
80206       {
80207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80208       };
80209     } catch (...) {
80210       {
80211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80212       };
80213     }
80214   }
80215   jresult = (void *)result;
80216   return jresult;
80217 }
80218
80219
80220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80221   void * jresult ;
80222   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80223   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80224
80225   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80226   {
80227     try {
80228       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80229     } catch (std::out_of_range& e) {
80230       {
80231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80232       };
80233     } catch (std::exception& e) {
80234       {
80235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80236       };
80237     } catch (...) {
80238       {
80239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80240       };
80241     }
80242   }
80243   jresult = (void *)result;
80244   return jresult;
80245 }
80246
80247
80248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80249   void * jresult ;
80250   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80251   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80252
80253   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80254   {
80255     try {
80256       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80257     } catch (std::out_of_range& e) {
80258       {
80259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80260       };
80261     } catch (std::exception& e) {
80262       {
80263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80264       };
80265     } catch (...) {
80266       {
80267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80268       };
80269     }
80270   }
80271   jresult = (void *)result;
80272   return jresult;
80273 }
80274
80275
80276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
80277   void * jresult ;
80278   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80279   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80280
80281   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80282   {
80283     try {
80284       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
80285     } catch (std::out_of_range& e) {
80286       {
80287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80288       };
80289     } catch (std::exception& e) {
80290       {
80291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80292       };
80293     } catch (...) {
80294       {
80295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80296       };
80297     }
80298   }
80299   jresult = (void *)result;
80300   return jresult;
80301 }
80302
80303
80304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80305   void * jresult ;
80306   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80307   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80308
80309   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80310   {
80311     try {
80312       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80313     } catch (std::out_of_range& e) {
80314       {
80315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80316       };
80317     } catch (std::exception& e) {
80318       {
80319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80320       };
80321     } catch (...) {
80322       {
80323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80324       };
80325     }
80326   }
80327   jresult = (void *)result;
80328   return jresult;
80329 }
80330
80331
80332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80333   void * jresult ;
80334   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80335   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80336
80337   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80338   {
80339     try {
80340       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80341     } catch (std::out_of_range& e) {
80342       {
80343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80344       };
80345     } catch (std::exception& e) {
80346       {
80347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80348       };
80349     } catch (...) {
80350       {
80351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80352       };
80353     }
80354   }
80355   jresult = (void *)result;
80356   return jresult;
80357 }
80358
80359
80360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80361   void * jresult ;
80362   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80363   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80364
80365   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80366   {
80367     try {
80368       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80369     } catch (std::out_of_range& e) {
80370       {
80371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80372       };
80373     } catch (std::exception& e) {
80374       {
80375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80376       };
80377     } catch (...) {
80378       {
80379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80380       };
80381     }
80382   }
80383   jresult = (void *)result;
80384   return jresult;
80385 }
80386
80387
80388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80389   void * jresult ;
80390   Dali::Toolkit::StyleManager *result = 0 ;
80391
80392   {
80393     try {
80394       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80395     } catch (std::out_of_range& e) {
80396       {
80397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80398       };
80399     } catch (std::exception& e) {
80400       {
80401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80402       };
80403     } catch (...) {
80404       {
80405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80406       };
80407     }
80408   }
80409   jresult = (void *)result;
80410   return jresult;
80411 }
80412
80413
80414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80415   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80416
80417   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80418   {
80419     try {
80420       delete arg1;
80421     } catch (std::out_of_range& e) {
80422       {
80423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80424       };
80425     } catch (std::exception& e) {
80426       {
80427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80428       };
80429     } catch (...) {
80430       {
80431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80432       };
80433     }
80434   }
80435 }
80436
80437
80438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80439   void * jresult ;
80440   Dali::Toolkit::StyleManager result;
80441
80442   {
80443     try {
80444       result = Dali::Toolkit::StyleManager::Get();
80445     } catch (std::out_of_range& e) {
80446       {
80447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80448       };
80449     } catch (std::exception& e) {
80450       {
80451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80452       };
80453     } catch (...) {
80454       {
80455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80456       };
80457     }
80458   }
80459   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80460   return jresult;
80461 }
80462
80463
80464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80465   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80466   std::string *arg2 = 0 ;
80467
80468   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80469   if (!jarg2) {
80470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80471     return ;
80472   }
80473   std::string arg2_str(jarg2);
80474   arg2 = &arg2_str;
80475   {
80476     try {
80477       (arg1)->ApplyTheme((std::string const &)*arg2);
80478     } catch (std::out_of_range& e) {
80479       {
80480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80481       };
80482     } catch (std::exception& e) {
80483       {
80484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80485       };
80486     } catch (...) {
80487       {
80488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80489       };
80490     }
80491   }
80492
80493   //argout typemap for const std::string&
80494
80495 }
80496
80497
80498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80499   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80500
80501   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80502   {
80503     try {
80504       (arg1)->ApplyDefaultTheme();
80505     } catch (std::out_of_range& e) {
80506       {
80507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80508       };
80509     } catch (std::exception& e) {
80510       {
80511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80512       };
80513     } catch (...) {
80514       {
80515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80516       };
80517     }
80518   }
80519 }
80520
80521
80522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80523   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80524   std::string *arg2 = 0 ;
80525   Dali::Property::Value *arg3 = 0 ;
80526
80527   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80528   if (!jarg2) {
80529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80530     return ;
80531   }
80532   std::string arg2_str(jarg2);
80533   arg2 = &arg2_str;
80534   arg3 = (Dali::Property::Value *)jarg3;
80535   if (!arg3) {
80536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80537     return ;
80538   }
80539   {
80540     try {
80541       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80542     } catch (std::out_of_range& e) {
80543       {
80544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80545       };
80546     } catch (std::exception& e) {
80547       {
80548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80549       };
80550     } catch (...) {
80551       {
80552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80553       };
80554     }
80555   }
80556
80557   //argout typemap for const std::string&
80558
80559 }
80560
80561
80562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80563   unsigned int jresult ;
80564   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80565   std::string *arg2 = 0 ;
80566   Dali::Property::Value *arg3 = 0 ;
80567   bool result;
80568
80569   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80570   if (!jarg2) {
80571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80572     return 0;
80573   }
80574   std::string arg2_str(jarg2);
80575   arg2 = &arg2_str;
80576   arg3 = (Dali::Property::Value *)jarg3;
80577   if (!arg3) {
80578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80579     return 0;
80580   }
80581   {
80582     try {
80583       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80584     } catch (std::out_of_range& e) {
80585       {
80586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80587       };
80588     } catch (std::exception& e) {
80589       {
80590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80591       };
80592     } catch (...) {
80593       {
80594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80595       };
80596     }
80597   }
80598   jresult = result;
80599
80600   //argout typemap for const std::string&
80601
80602   return jresult;
80603 }
80604
80605
80606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80607   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80608   Dali::Toolkit::Control arg2 ;
80609   std::string *arg3 = 0 ;
80610   std::string *arg4 = 0 ;
80611   Dali::Toolkit::Control *argp2 ;
80612
80613   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80614   argp2 = (Dali::Toolkit::Control *)jarg2;
80615   if (!argp2) {
80616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80617     return ;
80618   }
80619   arg2 = *argp2;
80620   if (!jarg3) {
80621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80622     return ;
80623   }
80624   std::string arg3_str(jarg3);
80625   arg3 = &arg3_str;
80626   if (!jarg4) {
80627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80628     return ;
80629   }
80630   std::string arg4_str(jarg4);
80631   arg4 = &arg4_str;
80632   {
80633     try {
80634       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80635     } catch (std::out_of_range& e) {
80636       {
80637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80638       };
80639     } catch (std::exception& e) {
80640       {
80641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80642       };
80643     } catch (...) {
80644       {
80645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80646       };
80647     }
80648   }
80649
80650   //argout typemap for const std::string&
80651
80652
80653   //argout typemap for const std::string&
80654
80655 }
80656
80657
80658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
80659   void * jresult ;
80660   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80661   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
80662
80663   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80664   {
80665     try {
80666       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
80667     } catch (std::out_of_range& e) {
80668       {
80669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80670       };
80671     } catch (std::exception& e) {
80672       {
80673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80674       };
80675     } catch (...) {
80676       {
80677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80678       };
80679     }
80680   }
80681   jresult = (void *)result;
80682   return jresult;
80683 }
80684
80685
80686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
80687   int jresult ;
80688   int result;
80689
80690   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
80691   jresult = (int)result;
80692   return jresult;
80693 }
80694
80695
80696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
80697   int jresult ;
80698   int result;
80699
80700   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
80701   jresult = (int)result;
80702   return jresult;
80703 }
80704
80705
80706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
80707   int jresult ;
80708   int result;
80709
80710   result = (int)Dali::Toolkit::Slider::Property::VALUE;
80711   jresult = (int)result;
80712   return jresult;
80713 }
80714
80715
80716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
80717   int jresult ;
80718   int result;
80719
80720   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
80721   jresult = (int)result;
80722   return jresult;
80723 }
80724
80725
80726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
80727   int jresult ;
80728   int result;
80729
80730   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
80731   jresult = (int)result;
80732   return jresult;
80733 }
80734
80735
80736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
80737   int jresult ;
80738   int result;
80739
80740   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
80741   jresult = (int)result;
80742   return jresult;
80743 }
80744
80745
80746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
80747   int jresult ;
80748   int result;
80749
80750   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
80751   jresult = (int)result;
80752   return jresult;
80753 }
80754
80755
80756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
80757   int jresult ;
80758   int result;
80759
80760   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
80761   jresult = (int)result;
80762   return jresult;
80763 }
80764
80765
80766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
80767   int jresult ;
80768   int result;
80769
80770   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
80771   jresult = (int)result;
80772   return jresult;
80773 }
80774
80775
80776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
80777   int jresult ;
80778   int result;
80779
80780   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
80781   jresult = (int)result;
80782   return jresult;
80783 }
80784
80785
80786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
80787   int jresult ;
80788   int result;
80789
80790   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
80791   jresult = (int)result;
80792   return jresult;
80793 }
80794
80795
80796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
80797   int jresult ;
80798   int result;
80799
80800   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
80801   jresult = (int)result;
80802   return jresult;
80803 }
80804
80805
80806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
80807   int jresult ;
80808   int result;
80809
80810   result = (int)Dali::Toolkit::Slider::Property::MARKS;
80811   jresult = (int)result;
80812   return jresult;
80813 }
80814
80815
80816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
80817   int jresult ;
80818   int result;
80819
80820   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
80821   jresult = (int)result;
80822   return jresult;
80823 }
80824
80825
80826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
80827   int jresult ;
80828   int result;
80829
80830   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
80831   jresult = (int)result;
80832   return jresult;
80833 }
80834
80835
80836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
80837   void * jresult ;
80838   Dali::Toolkit::Slider::Property *result = 0 ;
80839
80840   {
80841     try {
80842       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
80843     } catch (std::out_of_range& e) {
80844       {
80845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80846       };
80847     } catch (std::exception& e) {
80848       {
80849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80850       };
80851     } catch (...) {
80852       {
80853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80854       };
80855     }
80856   }
80857   jresult = (void *)result;
80858   return jresult;
80859 }
80860
80861
80862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
80863   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
80864
80865   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
80866   {
80867     try {
80868       delete arg1;
80869     } catch (std::out_of_range& e) {
80870       {
80871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80872       };
80873     } catch (std::exception& e) {
80874       {
80875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80876       };
80877     } catch (...) {
80878       {
80879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80880       };
80881     }
80882   }
80883 }
80884
80885
80886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
80887   void * jresult ;
80888   Dali::Toolkit::Slider result;
80889
80890   {
80891     try {
80892       result = Dali::Toolkit::Slider::New();
80893     } catch (std::out_of_range& e) {
80894       {
80895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80896       };
80897     } catch (std::exception& e) {
80898       {
80899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80900       };
80901     } catch (...) {
80902       {
80903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80904       };
80905     }
80906   }
80907   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
80908   return jresult;
80909 }
80910
80911
80912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
80913   void * jresult ;
80914   Dali::Toolkit::Slider *result = 0 ;
80915
80916   {
80917     try {
80918       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
80919     } catch (std::out_of_range& e) {
80920       {
80921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80922       };
80923     } catch (std::exception& e) {
80924       {
80925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80926       };
80927     } catch (...) {
80928       {
80929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80930       };
80931     }
80932   }
80933   jresult = (void *)result;
80934   return jresult;
80935 }
80936
80937
80938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
80939   void * jresult ;
80940   Dali::Toolkit::Slider *arg1 = 0 ;
80941   Dali::Toolkit::Slider *result = 0 ;
80942
80943   arg1 = (Dali::Toolkit::Slider *)jarg1;
80944   if (!arg1) {
80945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80946     return 0;
80947   }
80948   {
80949     try {
80950       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
80951     } catch (std::out_of_range& e) {
80952       {
80953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80954       };
80955     } catch (std::exception& e) {
80956       {
80957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80958       };
80959     } catch (...) {
80960       {
80961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80962       };
80963     }
80964   }
80965   jresult = (void *)result;
80966   return jresult;
80967 }
80968
80969
80970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
80971   void * jresult ;
80972   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
80973   Dali::Toolkit::Slider *arg2 = 0 ;
80974   Dali::Toolkit::Slider *result = 0 ;
80975
80976   arg1 = (Dali::Toolkit::Slider *)jarg1;
80977   arg2 = (Dali::Toolkit::Slider *)jarg2;
80978   if (!arg2) {
80979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
80980     return 0;
80981   }
80982   {
80983     try {
80984       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
80985     } catch (std::out_of_range& e) {
80986       {
80987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80988       };
80989     } catch (std::exception& e) {
80990       {
80991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80992       };
80993     } catch (...) {
80994       {
80995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80996       };
80997     }
80998   }
80999   jresult = (void *)result;
81000   return jresult;
81001 }
81002
81003
81004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81005   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81006
81007   arg1 = (Dali::Toolkit::Slider *)jarg1;
81008   {
81009     try {
81010       delete arg1;
81011     } catch (std::out_of_range& e) {
81012       {
81013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81014       };
81015     } catch (std::exception& e) {
81016       {
81017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81018       };
81019     } catch (...) {
81020       {
81021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81022       };
81023     }
81024   }
81025 }
81026
81027
81028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81029   void * jresult ;
81030   Dali::BaseHandle arg1 ;
81031   Dali::BaseHandle *argp1 ;
81032   Dali::Toolkit::Slider result;
81033
81034   argp1 = (Dali::BaseHandle *)jarg1;
81035   if (!argp1) {
81036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81037     return 0;
81038   }
81039   arg1 = *argp1;
81040   {
81041     try {
81042       result = Dali::Toolkit::Slider::DownCast(arg1);
81043     } catch (std::out_of_range& e) {
81044       {
81045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81046       };
81047     } catch (std::exception& e) {
81048       {
81049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81050       };
81051     } catch (...) {
81052       {
81053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81054       };
81055     }
81056   }
81057   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81058   return jresult;
81059 }
81060
81061
81062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81063   void * jresult ;
81064   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81065   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81066
81067   arg1 = (Dali::Toolkit::Slider *)jarg1;
81068   {
81069     try {
81070       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81071     } catch (std::out_of_range& e) {
81072       {
81073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81074       };
81075     } catch (std::exception& e) {
81076       {
81077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81078       };
81079     } catch (...) {
81080       {
81081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81082       };
81083     }
81084   }
81085   jresult = (void *)result;
81086   return jresult;
81087 }
81088
81089
81090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81091   void * jresult ;
81092   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81093   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81094
81095   arg1 = (Dali::Toolkit::Slider *)jarg1;
81096   {
81097     try {
81098       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81099     } catch (std::out_of_range& e) {
81100       {
81101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81102       };
81103     } catch (std::exception& e) {
81104       {
81105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81106       };
81107     } catch (...) {
81108       {
81109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81110       };
81111     }
81112   }
81113   jresult = (void *)result;
81114   return jresult;
81115 }
81116
81117
81118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81119   void * jresult ;
81120   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81121   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81122
81123   arg1 = (Dali::Toolkit::Slider *)jarg1;
81124   {
81125     try {
81126       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81127     } catch (std::out_of_range& e) {
81128       {
81129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81130       };
81131     } catch (std::exception& e) {
81132       {
81133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81134       };
81135     } catch (...) {
81136       {
81137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81138       };
81139     }
81140   }
81141   jresult = (void *)result;
81142   return jresult;
81143 }
81144
81145
81146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81147   int jresult ;
81148   int result;
81149
81150   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81151   jresult = (int)result;
81152   return jresult;
81153 }
81154
81155
81156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81157   int jresult ;
81158   int result;
81159
81160   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81161   jresult = (int)result;
81162   return jresult;
81163 }
81164
81165
81166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81167   int jresult ;
81168   int result;
81169
81170   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81171   jresult = (int)result;
81172   return jresult;
81173 }
81174
81175
81176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81177   int jresult ;
81178   int result;
81179
81180   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81181   jresult = (int)result;
81182   return jresult;
81183 }
81184
81185
81186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81187   void * jresult ;
81188   Dali::Toolkit::VideoView::Property *result = 0 ;
81189
81190   {
81191     try {
81192       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81193     } catch (std::out_of_range& e) {
81194       {
81195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81196       };
81197     } catch (std::exception& e) {
81198       {
81199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81200       };
81201     } catch (...) {
81202       {
81203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81204       };
81205     }
81206   }
81207   jresult = (void *)result;
81208   return jresult;
81209 }
81210
81211
81212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81213   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81214
81215   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81216   {
81217     try {
81218       delete arg1;
81219     } catch (std::out_of_range& e) {
81220       {
81221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81222       };
81223     } catch (std::exception& e) {
81224       {
81225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81226       };
81227     } catch (...) {
81228       {
81229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81230       };
81231     }
81232   }
81233 }
81234
81235
81236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81237   void * jresult ;
81238   Dali::Toolkit::VideoView result;
81239
81240   {
81241     try {
81242       result = Dali::Toolkit::VideoView::New();
81243     } catch (std::out_of_range& e) {
81244       {
81245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81246       };
81247     } catch (std::exception& e) {
81248       {
81249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81250       };
81251     } catch (...) {
81252       {
81253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81254       };
81255     }
81256   }
81257   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81258   return jresult;
81259 }
81260
81261
81262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81263   void * jresult ;
81264   std::string *arg1 = 0 ;
81265   Dali::Toolkit::VideoView result;
81266
81267   if (!jarg1) {
81268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81269     return 0;
81270   }
81271   std::string arg1_str(jarg1);
81272   arg1 = &arg1_str;
81273   {
81274     try {
81275       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81276     } catch (std::out_of_range& e) {
81277       {
81278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81279       };
81280     } catch (std::exception& e) {
81281       {
81282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81283       };
81284     } catch (...) {
81285       {
81286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81287       };
81288     }
81289   }
81290   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81291
81292   //argout typemap for const std::string&
81293
81294   return jresult;
81295 }
81296
81297
81298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81299   void * jresult ;
81300   Dali::Toolkit::VideoView *result = 0 ;
81301
81302   {
81303     try {
81304       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81305     } catch (std::out_of_range& e) {
81306       {
81307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81308       };
81309     } catch (std::exception& e) {
81310       {
81311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81312       };
81313     } catch (...) {
81314       {
81315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81316       };
81317     }
81318   }
81319   jresult = (void *)result;
81320   return jresult;
81321 }
81322
81323
81324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81325   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81326
81327   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81328   {
81329     try {
81330       delete arg1;
81331     } catch (std::out_of_range& e) {
81332       {
81333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81334       };
81335     } catch (std::exception& e) {
81336       {
81337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81338       };
81339     } catch (...) {
81340       {
81341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81342       };
81343     }
81344   }
81345 }
81346
81347
81348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81349   void * jresult ;
81350   Dali::Toolkit::VideoView *arg1 = 0 ;
81351   Dali::Toolkit::VideoView *result = 0 ;
81352
81353   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81354   if (!arg1) {
81355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81356     return 0;
81357   }
81358   {
81359     try {
81360       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81361     } catch (std::out_of_range& e) {
81362       {
81363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81364       };
81365     } catch (std::exception& e) {
81366       {
81367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81368       };
81369     } catch (...) {
81370       {
81371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81372       };
81373     }
81374   }
81375   jresult = (void *)result;
81376   return jresult;
81377 }
81378
81379
81380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
81381   void * jresult ;
81382   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81383   Dali::Toolkit::VideoView *arg2 = 0 ;
81384   Dali::Toolkit::VideoView *result = 0 ;
81385
81386   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81387   arg2 = (Dali::Toolkit::VideoView *)jarg2;
81388   if (!arg2) {
81389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81390     return 0;
81391   }
81392   {
81393     try {
81394       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
81395     } catch (std::out_of_range& e) {
81396       {
81397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81398       };
81399     } catch (std::exception& e) {
81400       {
81401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81402       };
81403     } catch (...) {
81404       {
81405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81406       };
81407     }
81408   }
81409   jresult = (void *)result;
81410   return jresult;
81411 }
81412
81413
81414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
81415   void * jresult ;
81416   Dali::BaseHandle arg1 ;
81417   Dali::BaseHandle *argp1 ;
81418   Dali::Toolkit::VideoView result;
81419
81420   argp1 = (Dali::BaseHandle *)jarg1;
81421   if (!argp1) {
81422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81423     return 0;
81424   }
81425   arg1 = *argp1;
81426   {
81427     try {
81428       result = Dali::Toolkit::VideoView::DownCast(arg1);
81429     } catch (std::out_of_range& e) {
81430       {
81431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81432       };
81433     } catch (std::exception& e) {
81434       {
81435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81436       };
81437     } catch (...) {
81438       {
81439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81440       };
81441     }
81442   }
81443   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81444   return jresult;
81445 }
81446
81447
81448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
81449   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81450
81451   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81452   {
81453     try {
81454       (arg1)->Play();
81455     } catch (std::out_of_range& e) {
81456       {
81457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81458       };
81459     } catch (std::exception& e) {
81460       {
81461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81462       };
81463     } catch (...) {
81464       {
81465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81466       };
81467     }
81468   }
81469 }
81470
81471
81472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
81473   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81474
81475   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81476   {
81477     try {
81478       (arg1)->Pause();
81479     } catch (std::out_of_range& e) {
81480       {
81481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81482       };
81483     } catch (std::exception& e) {
81484       {
81485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81486       };
81487     } catch (...) {
81488       {
81489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81490       };
81491     }
81492   }
81493 }
81494
81495
81496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
81497   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81498
81499   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81500   {
81501     try {
81502       (arg1)->Stop();
81503     } catch (std::out_of_range& e) {
81504       {
81505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81506       };
81507     } catch (std::exception& e) {
81508       {
81509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81510       };
81511     } catch (...) {
81512       {
81513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81514       };
81515     }
81516   }
81517 }
81518
81519
81520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
81521   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81522   int arg2 ;
81523
81524   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81525   arg2 = (int)jarg2;
81526   {
81527     try {
81528       (arg1)->Forward(arg2);
81529     } catch (std::out_of_range& e) {
81530       {
81531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81532       };
81533     } catch (std::exception& e) {
81534       {
81535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81536       };
81537     } catch (...) {
81538       {
81539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81540       };
81541     }
81542   }
81543 }
81544
81545
81546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
81547   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81548   int arg2 ;
81549
81550   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81551   arg2 = (int)jarg2;
81552   {
81553     try {
81554       (arg1)->Backward(arg2);
81555     } catch (std::out_of_range& e) {
81556       {
81557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81558       };
81559     } catch (std::exception& e) {
81560       {
81561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81562       };
81563     } catch (...) {
81564       {
81565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81566       };
81567     }
81568   }
81569 }
81570
81571
81572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
81573   void * jresult ;
81574   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81575   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
81576
81577   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81578   {
81579     try {
81580       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
81581     } catch (std::out_of_range& e) {
81582       {
81583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81584       };
81585     } catch (std::exception& e) {
81586       {
81587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81588       };
81589     } catch (...) {
81590       {
81591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81592       };
81593     }
81594   }
81595   jresult = (void *)result;
81596   return jresult;
81597 }
81598
81599
81600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
81601   int jresult ;
81602   int result;
81603
81604   result = (int)Dali::Toolkit::Popup::Property::TITLE;
81605   jresult = (int)result;
81606   return jresult;
81607 }
81608
81609
81610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
81611   int jresult ;
81612   int result;
81613
81614   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
81615   jresult = (int)result;
81616   return jresult;
81617 }
81618
81619
81620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
81621   int jresult ;
81622   int result;
81623
81624   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
81625   jresult = (int)result;
81626   return jresult;
81627 }
81628
81629
81630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
81631   int jresult ;
81632   int result;
81633
81634   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
81635   jresult = (int)result;
81636   return jresult;
81637 }
81638
81639
81640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
81641   int jresult ;
81642   int result;
81643
81644   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
81645   jresult = (int)result;
81646   return jresult;
81647 }
81648
81649
81650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
81651   int jresult ;
81652   int result;
81653
81654   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
81655   jresult = (int)result;
81656   return jresult;
81657 }
81658
81659
81660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
81661   int jresult ;
81662   int result;
81663
81664   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
81665   jresult = (int)result;
81666   return jresult;
81667 }
81668
81669
81670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
81671   int jresult ;
81672   int result;
81673
81674   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
81675   jresult = (int)result;
81676   return jresult;
81677 }
81678
81679
81680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
81681   int jresult ;
81682   int result;
81683
81684   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
81685   jresult = (int)result;
81686   return jresult;
81687 }
81688
81689
81690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
81691   int jresult ;
81692   int result;
81693
81694   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
81695   jresult = (int)result;
81696   return jresult;
81697 }
81698
81699
81700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
81701   int jresult ;
81702   int result;
81703
81704   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
81705   jresult = (int)result;
81706   return jresult;
81707 }
81708
81709
81710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
81711   int jresult ;
81712   int result;
81713
81714   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
81715   jresult = (int)result;
81716   return jresult;
81717 }
81718
81719
81720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
81721   int jresult ;
81722   int result;
81723
81724   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
81725   jresult = (int)result;
81726   return jresult;
81727 }
81728
81729
81730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
81731   int jresult ;
81732   int result;
81733
81734   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
81735   jresult = (int)result;
81736   return jresult;
81737 }
81738
81739
81740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
81741   int jresult ;
81742   int result;
81743
81744   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
81745   jresult = (int)result;
81746   return jresult;
81747 }
81748
81749
81750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
81751   int jresult ;
81752   int result;
81753
81754   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
81755   jresult = (int)result;
81756   return jresult;
81757 }
81758
81759
81760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
81761   int jresult ;
81762   int result;
81763
81764   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
81765   jresult = (int)result;
81766   return jresult;
81767 }
81768
81769
81770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
81771   int jresult ;
81772   int result;
81773
81774   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
81775   jresult = (int)result;
81776   return jresult;
81777 }
81778
81779
81780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
81781   int jresult ;
81782   int result;
81783
81784   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
81785   jresult = (int)result;
81786   return jresult;
81787 }
81788
81789
81790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
81791   int jresult ;
81792   int result;
81793
81794   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
81795   jresult = (int)result;
81796   return jresult;
81797 }
81798
81799
81800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
81801   int jresult ;
81802   int result;
81803
81804   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
81805   jresult = (int)result;
81806   return jresult;
81807 }
81808
81809
81810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
81811   void * jresult ;
81812   Dali::Toolkit::Popup::Property *result = 0 ;
81813
81814   {
81815     try {
81816       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
81817     } catch (std::out_of_range& e) {
81818       {
81819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81820       };
81821     } catch (std::exception& e) {
81822       {
81823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81824       };
81825     } catch (...) {
81826       {
81827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81828       };
81829     }
81830   }
81831   jresult = (void *)result;
81832   return jresult;
81833 }
81834
81835
81836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
81837   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
81838
81839   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
81840   {
81841     try {
81842       delete arg1;
81843     } catch (std::out_of_range& e) {
81844       {
81845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81846       };
81847     } catch (std::exception& e) {
81848       {
81849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81850       };
81851     } catch (...) {
81852       {
81853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81854       };
81855     }
81856   }
81857 }
81858
81859
81860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
81861   void * jresult ;
81862   Dali::Toolkit::Popup *result = 0 ;
81863
81864   {
81865     try {
81866       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
81867     } catch (std::out_of_range& e) {
81868       {
81869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81870       };
81871     } catch (std::exception& e) {
81872       {
81873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81874       };
81875     } catch (...) {
81876       {
81877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81878       };
81879     }
81880   }
81881   jresult = (void *)result;
81882   return jresult;
81883 }
81884
81885
81886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
81887   void * jresult ;
81888   Dali::Toolkit::Popup result;
81889
81890   {
81891     try {
81892       result = Dali::Toolkit::Popup::New();
81893     } catch (std::out_of_range& e) {
81894       {
81895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81896       };
81897     } catch (std::exception& e) {
81898       {
81899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81900       };
81901     } catch (...) {
81902       {
81903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81904       };
81905     }
81906   }
81907   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
81908   return jresult;
81909 }
81910
81911
81912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
81913   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81914
81915   arg1 = (Dali::Toolkit::Popup *)jarg1;
81916   {
81917     try {
81918       delete arg1;
81919     } catch (std::out_of_range& e) {
81920       {
81921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81922       };
81923     } catch (std::exception& e) {
81924       {
81925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81926       };
81927     } catch (...) {
81928       {
81929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81930       };
81931     }
81932   }
81933 }
81934
81935
81936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
81937   void * jresult ;
81938   Dali::Toolkit::Popup *arg1 = 0 ;
81939   Dali::Toolkit::Popup *result = 0 ;
81940
81941   arg1 = (Dali::Toolkit::Popup *)jarg1;
81942   if (!arg1) {
81943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81944     return 0;
81945   }
81946   {
81947     try {
81948       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
81949     } catch (std::out_of_range& e) {
81950       {
81951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81952       };
81953     } catch (std::exception& e) {
81954       {
81955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81956       };
81957     } catch (...) {
81958       {
81959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81960       };
81961     }
81962   }
81963   jresult = (void *)result;
81964   return jresult;
81965 }
81966
81967
81968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
81969   void * jresult ;
81970   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
81971   Dali::Toolkit::Popup *arg2 = 0 ;
81972   Dali::Toolkit::Popup *result = 0 ;
81973
81974   arg1 = (Dali::Toolkit::Popup *)jarg1;
81975   arg2 = (Dali::Toolkit::Popup *)jarg2;
81976   if (!arg2) {
81977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
81978     return 0;
81979   }
81980   {
81981     try {
81982       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
81983     } catch (std::out_of_range& e) {
81984       {
81985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81986       };
81987     } catch (std::exception& e) {
81988       {
81989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81990       };
81991     } catch (...) {
81992       {
81993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81994       };
81995     }
81996   }
81997   jresult = (void *)result;
81998   return jresult;
81999 }
82000
82001
82002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82003   void * jresult ;
82004   Dali::BaseHandle arg1 ;
82005   Dali::BaseHandle *argp1 ;
82006   Dali::Toolkit::Popup result;
82007
82008   argp1 = (Dali::BaseHandle *)jarg1;
82009   if (!argp1) {
82010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82011     return 0;
82012   }
82013   arg1 = *argp1;
82014   {
82015     try {
82016       result = Dali::Toolkit::Popup::DownCast(arg1);
82017     } catch (std::out_of_range& e) {
82018       {
82019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82020       };
82021     } catch (std::exception& e) {
82022       {
82023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82024       };
82025     } catch (...) {
82026       {
82027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82028       };
82029     }
82030   }
82031   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82032   return jresult;
82033 }
82034
82035
82036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82037   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82038   Dali::Actor arg2 ;
82039   Dali::Actor *argp2 ;
82040
82041   arg1 = (Dali::Toolkit::Popup *)jarg1;
82042   argp2 = (Dali::Actor *)jarg2;
82043   if (!argp2) {
82044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82045     return ;
82046   }
82047   arg2 = *argp2;
82048   {
82049     try {
82050       (arg1)->SetTitle(arg2);
82051     } catch (std::out_of_range& e) {
82052       {
82053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82054       };
82055     } catch (std::exception& e) {
82056       {
82057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82058       };
82059     } catch (...) {
82060       {
82061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82062       };
82063     }
82064   }
82065 }
82066
82067
82068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82069   void * jresult ;
82070   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82071   Dali::Actor result;
82072
82073   arg1 = (Dali::Toolkit::Popup *)jarg1;
82074   {
82075     try {
82076       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82077     } catch (std::out_of_range& e) {
82078       {
82079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82080       };
82081     } catch (std::exception& e) {
82082       {
82083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82084       };
82085     } catch (...) {
82086       {
82087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82088       };
82089     }
82090   }
82091   jresult = new Dali::Actor((const Dali::Actor &)result);
82092   return jresult;
82093 }
82094
82095
82096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82097   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82098   Dali::Actor arg2 ;
82099   Dali::Actor *argp2 ;
82100
82101   arg1 = (Dali::Toolkit::Popup *)jarg1;
82102   argp2 = (Dali::Actor *)jarg2;
82103   if (!argp2) {
82104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82105     return ;
82106   }
82107   arg2 = *argp2;
82108   {
82109     try {
82110       (arg1)->SetContent(arg2);
82111     } catch (std::out_of_range& e) {
82112       {
82113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82114       };
82115     } catch (std::exception& e) {
82116       {
82117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82118       };
82119     } catch (...) {
82120       {
82121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82122       };
82123     }
82124   }
82125 }
82126
82127
82128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
82129   void * jresult ;
82130   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82131   Dali::Actor result;
82132
82133   arg1 = (Dali::Toolkit::Popup *)jarg1;
82134   {
82135     try {
82136       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82137     } catch (std::out_of_range& e) {
82138       {
82139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82140       };
82141     } catch (std::exception& e) {
82142       {
82143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82144       };
82145     } catch (...) {
82146       {
82147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82148       };
82149     }
82150   }
82151   jresult = new Dali::Actor((const Dali::Actor &)result);
82152   return jresult;
82153 }
82154
82155
82156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82157   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82158   Dali::Actor arg2 ;
82159   Dali::Actor *argp2 ;
82160
82161   arg1 = (Dali::Toolkit::Popup *)jarg1;
82162   argp2 = (Dali::Actor *)jarg2;
82163   if (!argp2) {
82164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82165     return ;
82166   }
82167   arg2 = *argp2;
82168   {
82169     try {
82170       (arg1)->SetFooter(arg2);
82171     } catch (std::out_of_range& e) {
82172       {
82173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82174       };
82175     } catch (std::exception& e) {
82176       {
82177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82178       };
82179     } catch (...) {
82180       {
82181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82182       };
82183     }
82184   }
82185 }
82186
82187
82188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82189   void * jresult ;
82190   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82191   Dali::Actor result;
82192
82193   arg1 = (Dali::Toolkit::Popup *)jarg1;
82194   {
82195     try {
82196       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82197     } catch (std::out_of_range& e) {
82198       {
82199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82200       };
82201     } catch (std::exception& e) {
82202       {
82203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82204       };
82205     } catch (...) {
82206       {
82207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82208       };
82209     }
82210   }
82211   jresult = new Dali::Actor((const Dali::Actor &)result);
82212   return jresult;
82213 }
82214
82215
82216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
82217   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82218   Dali::Toolkit::Popup::DisplayState arg2 ;
82219
82220   arg1 = (Dali::Toolkit::Popup *)jarg1;
82221   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82222   {
82223     try {
82224       (arg1)->SetDisplayState(arg2);
82225     } catch (std::out_of_range& e) {
82226       {
82227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82228       };
82229     } catch (std::exception& e) {
82230       {
82231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82232       };
82233     } catch (...) {
82234       {
82235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82236       };
82237     }
82238   }
82239 }
82240
82241
82242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
82243   int jresult ;
82244   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82245   Dali::Toolkit::Popup::DisplayState result;
82246
82247   arg1 = (Dali::Toolkit::Popup *)jarg1;
82248   {
82249     try {
82250       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82251     } catch (std::out_of_range& e) {
82252       {
82253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82254       };
82255     } catch (std::exception& e) {
82256       {
82257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82258       };
82259     } catch (...) {
82260       {
82261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82262       };
82263     }
82264   }
82265   jresult = (int)result;
82266   return jresult;
82267 }
82268
82269
82270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
82271   void * jresult ;
82272   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82273   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82274
82275   arg1 = (Dali::Toolkit::Popup *)jarg1;
82276   {
82277     try {
82278       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82279     } catch (std::out_of_range& e) {
82280       {
82281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82282       };
82283     } catch (std::exception& e) {
82284       {
82285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82286       };
82287     } catch (...) {
82288       {
82289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82290       };
82291     }
82292   }
82293   jresult = (void *)result;
82294   return jresult;
82295 }
82296
82297
82298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
82299   void * jresult ;
82300   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82301   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82302
82303   arg1 = (Dali::Toolkit::Popup *)jarg1;
82304   {
82305     try {
82306       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
82307     } catch (std::out_of_range& e) {
82308       {
82309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82310       };
82311     } catch (std::exception& e) {
82312       {
82313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82314       };
82315     } catch (...) {
82316       {
82317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82318       };
82319     }
82320   }
82321   jresult = (void *)result;
82322   return jresult;
82323 }
82324
82325
82326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
82327   void * jresult ;
82328   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82329   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82330
82331   arg1 = (Dali::Toolkit::Popup *)jarg1;
82332   {
82333     try {
82334       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
82335     } catch (std::out_of_range& e) {
82336       {
82337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82338       };
82339     } catch (std::exception& e) {
82340       {
82341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82342       };
82343     } catch (...) {
82344       {
82345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82346       };
82347     }
82348   }
82349   jresult = (void *)result;
82350   return jresult;
82351 }
82352
82353
82354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
82355   void * jresult ;
82356   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82357   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82358
82359   arg1 = (Dali::Toolkit::Popup *)jarg1;
82360   {
82361     try {
82362       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
82363     } catch (std::out_of_range& e) {
82364       {
82365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82366       };
82367     } catch (std::exception& e) {
82368       {
82369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82370       };
82371     } catch (...) {
82372       {
82373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82374       };
82375     }
82376   }
82377   jresult = (void *)result;
82378   return jresult;
82379 }
82380
82381
82382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
82383   void * jresult ;
82384   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82385   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82386
82387   arg1 = (Dali::Toolkit::Popup *)jarg1;
82388   {
82389     try {
82390       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
82391     } catch (std::out_of_range& e) {
82392       {
82393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82394       };
82395     } catch (std::exception& e) {
82396       {
82397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82398       };
82399     } catch (...) {
82400       {
82401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82402       };
82403     }
82404   }
82405   jresult = (void *)result;
82406   return jresult;
82407 }
82408
82409
82410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
82411   int jresult ;
82412   int result;
82413
82414   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
82415   jresult = (int)result;
82416   return jresult;
82417 }
82418
82419
82420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
82421   int jresult ;
82422   int result;
82423
82424   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
82425   jresult = (int)result;
82426   return jresult;
82427 }
82428
82429
82430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
82431   int jresult ;
82432   int result;
82433
82434   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
82435   jresult = (int)result;
82436   return jresult;
82437 }
82438
82439
82440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
82441   int jresult ;
82442   int result;
82443
82444   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
82445   jresult = (int)result;
82446   return jresult;
82447 }
82448
82449
82450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
82451   int jresult ;
82452   int result;
82453
82454   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
82455   jresult = (int)result;
82456   return jresult;
82457 }
82458
82459
82460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
82461   int jresult ;
82462   int result;
82463
82464   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
82465   jresult = (int)result;
82466   return jresult;
82467 }
82468
82469
82470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
82471   int jresult ;
82472   int result;
82473
82474   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
82475   jresult = (int)result;
82476   return jresult;
82477 }
82478
82479
82480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
82481   int jresult ;
82482   int result;
82483
82484   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
82485   jresult = (int)result;
82486   return jresult;
82487 }
82488
82489
82490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
82491   int jresult ;
82492   int result;
82493
82494   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
82495   jresult = (int)result;
82496   return jresult;
82497 }
82498
82499
82500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
82501   void * jresult ;
82502   Dali::Toolkit::ProgressBar::Property *result = 0 ;
82503
82504   {
82505     try {
82506       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
82507     } catch (std::out_of_range& e) {
82508       {
82509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82510       };
82511     } catch (std::exception& e) {
82512       {
82513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82514       };
82515     } catch (...) {
82516       {
82517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82518       };
82519     }
82520   }
82521   jresult = (void *)result;
82522   return jresult;
82523 }
82524
82525
82526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
82527   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
82528
82529   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
82530   {
82531     try {
82532       delete arg1;
82533     } catch (std::out_of_range& e) {
82534       {
82535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82536       };
82537     } catch (std::exception& e) {
82538       {
82539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82540       };
82541     } catch (...) {
82542       {
82543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82544       };
82545     }
82546   }
82547 }
82548
82549
82550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
82551   void * jresult ;
82552   Dali::Toolkit::ProgressBar result;
82553
82554   {
82555     try {
82556       result = Dali::Toolkit::ProgressBar::New();
82557     } catch (std::out_of_range& e) {
82558       {
82559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82560       };
82561     } catch (std::exception& e) {
82562       {
82563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82564       };
82565     } catch (...) {
82566       {
82567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82568       };
82569     }
82570   }
82571   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82572   return jresult;
82573 }
82574
82575
82576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
82577   void * jresult ;
82578   Dali::Toolkit::ProgressBar *result = 0 ;
82579
82580   {
82581     try {
82582       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
82583     } catch (std::out_of_range& e) {
82584       {
82585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82586       };
82587     } catch (std::exception& e) {
82588       {
82589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82590       };
82591     } catch (...) {
82592       {
82593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82594       };
82595     }
82596   }
82597   jresult = (void *)result;
82598   return jresult;
82599 }
82600
82601
82602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
82603   void * jresult ;
82604   Dali::Toolkit::ProgressBar *arg1 = 0 ;
82605   Dali::Toolkit::ProgressBar *result = 0 ;
82606
82607   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82608   if (!arg1) {
82609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82610     return 0;
82611   }
82612   {
82613     try {
82614       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
82615     } catch (std::out_of_range& e) {
82616       {
82617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82618       };
82619     } catch (std::exception& e) {
82620       {
82621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82622       };
82623     } catch (...) {
82624       {
82625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82626       };
82627     }
82628   }
82629   jresult = (void *)result;
82630   return jresult;
82631 }
82632
82633
82634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
82635   void * jresult ;
82636   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82637   Dali::Toolkit::ProgressBar *arg2 = 0 ;
82638   Dali::Toolkit::ProgressBar *result = 0 ;
82639
82640   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82641   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
82642   if (!arg2) {
82643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
82644     return 0;
82645   }
82646   {
82647     try {
82648       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
82649     } catch (std::out_of_range& e) {
82650       {
82651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82652       };
82653     } catch (std::exception& e) {
82654       {
82655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82656       };
82657     } catch (...) {
82658       {
82659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82660       };
82661     }
82662   }
82663   jresult = (void *)result;
82664   return jresult;
82665 }
82666
82667
82668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
82669   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82670
82671   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82672   {
82673     try {
82674       delete arg1;
82675     } catch (std::out_of_range& e) {
82676       {
82677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82678       };
82679     } catch (std::exception& e) {
82680       {
82681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82682       };
82683     } catch (...) {
82684       {
82685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82686       };
82687     }
82688   }
82689 }
82690
82691
82692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
82693   void * jresult ;
82694   Dali::BaseHandle arg1 ;
82695   Dali::BaseHandle *argp1 ;
82696   Dali::Toolkit::ProgressBar result;
82697
82698   argp1 = (Dali::BaseHandle *)jarg1;
82699   if (!argp1) {
82700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82701     return 0;
82702   }
82703   arg1 = *argp1;
82704   {
82705     try {
82706       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
82707     } catch (std::out_of_range& e) {
82708       {
82709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82710       };
82711     } catch (std::exception& e) {
82712       {
82713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82714       };
82715     } catch (...) {
82716       {
82717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82718       };
82719     }
82720   }
82721   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
82722   return jresult;
82723 }
82724
82725
82726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
82727   void * jresult ;
82728   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
82729   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
82730
82731   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
82732   {
82733     try {
82734       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82735     } catch (std::out_of_range& e) {
82736       {
82737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82738       };
82739     } catch (std::exception& e) {
82740       {
82741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82742       };
82743     } catch (...) {
82744       {
82745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82746       };
82747     }
82748   }
82749   jresult = (void *)result;
82750   return jresult;
82751 }
82752
82753
82754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
82755   void * jresult ;
82756   Dali::Toolkit::GaussianBlurView *result = 0 ;
82757
82758   {
82759     try {
82760       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
82761     } catch (std::out_of_range& e) {
82762       {
82763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82764       };
82765     } catch (std::exception& e) {
82766       {
82767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82768       };
82769     } catch (...) {
82770       {
82771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82772       };
82773     }
82774   }
82775   jresult = (void *)result;
82776   return jresult;
82777 }
82778
82779
82780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
82781   void * jresult ;
82782   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
82783   Dali::Toolkit::GaussianBlurView *result = 0 ;
82784
82785   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82786   if (!arg1) {
82787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82788     return 0;
82789   }
82790   {
82791     try {
82792       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
82793     } catch (std::out_of_range& e) {
82794       {
82795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82796       };
82797     } catch (std::exception& e) {
82798       {
82799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82800       };
82801     } catch (...) {
82802       {
82803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82804       };
82805     }
82806   }
82807   jresult = (void *)result;
82808   return jresult;
82809 }
82810
82811
82812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
82813   void * jresult ;
82814   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82815   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
82816   Dali::Toolkit::GaussianBlurView *result = 0 ;
82817
82818   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82819   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
82820   if (!arg2) {
82821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
82822     return 0;
82823   }
82824   {
82825     try {
82826       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
82827     } catch (std::out_of_range& e) {
82828       {
82829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82830       };
82831     } catch (std::exception& e) {
82832       {
82833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82834       };
82835     } catch (...) {
82836       {
82837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82838       };
82839     }
82840   }
82841   jresult = (void *)result;
82842   return jresult;
82843 }
82844
82845
82846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
82847   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
82848
82849   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
82850   {
82851     try {
82852       delete arg1;
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_DownCast(void * jarg1) {
82871   void * jresult ;
82872   Dali::BaseHandle arg1 ;
82873   Dali::BaseHandle *argp1 ;
82874   Dali::Toolkit::GaussianBlurView result;
82875
82876   argp1 = (Dali::BaseHandle *)jarg1;
82877   if (!argp1) {
82878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82879     return 0;
82880   }
82881   arg1 = *argp1;
82882   {
82883     try {
82884       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
82885     } catch (std::out_of_range& e) {
82886       {
82887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82888       };
82889     } catch (std::exception& e) {
82890       {
82891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82892       };
82893     } catch (...) {
82894       {
82895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82896       };
82897     }
82898   }
82899   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82900   return jresult;
82901 }
82902
82903
82904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
82905   void * jresult ;
82906   Dali::Toolkit::GaussianBlurView result;
82907
82908   {
82909     try {
82910       result = Dali::Toolkit::GaussianBlurView::New();
82911     } catch (std::out_of_range& e) {
82912       {
82913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82914       };
82915     } catch (std::exception& e) {
82916       {
82917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82918       };
82919     } catch (...) {
82920       {
82921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82922       };
82923     }
82924   }
82925   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82926   return jresult;
82927 }
82928
82929
82930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
82931   void * jresult ;
82932   unsigned int arg1 ;
82933   float arg2 ;
82934   Dali::Pixel::Format arg3 ;
82935   float arg4 ;
82936   float arg5 ;
82937   bool arg6 ;
82938   Dali::Toolkit::GaussianBlurView result;
82939
82940   arg1 = (unsigned int)jarg1;
82941   arg2 = (float)jarg2;
82942   arg3 = (Dali::Pixel::Format)jarg3;
82943   arg4 = (float)jarg4;
82944   arg5 = (float)jarg5;
82945   arg6 = jarg6 ? true : false;
82946   {
82947     try {
82948       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
82949     } catch (std::out_of_range& e) {
82950       {
82951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82952       };
82953     } catch (std::exception& e) {
82954       {
82955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82956       };
82957     } catch (...) {
82958       {
82959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82960       };
82961     }
82962   }
82963   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
82964   return jresult;
82965 }
82966
82967
82968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
82969   void * jresult ;
82970   unsigned int arg1 ;
82971   float arg2 ;
82972   Dali::Pixel::Format arg3 ;
82973   float arg4 ;
82974   float arg5 ;
82975   Dali::Toolkit::GaussianBlurView result;
82976
82977   arg1 = (unsigned int)jarg1;
82978   arg2 = (float)jarg2;
82979   arg3 = (Dali::Pixel::Format)jarg3;
82980   arg4 = (float)jarg4;
82981   arg5 = (float)jarg5;
82982   {
82983     try {
82984       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
82985     } catch (std::out_of_range& e) {
82986       {
82987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82988       };
82989     } catch (std::exception& e) {
82990       {
82991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82992       };
82993     } catch (...) {
82994       {
82995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82996       };
82997     }
82998   }
82999   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83000   return jresult;
83001 }
83002
83003
83004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83005   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83006   Dali::Actor arg2 ;
83007   Dali::Actor *argp2 ;
83008
83009   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83010   argp2 = (Dali::Actor *)jarg2;
83011   if (!argp2) {
83012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83013     return ;
83014   }
83015   arg2 = *argp2;
83016   {
83017     try {
83018       (arg1)->Add(arg2);
83019     } catch (std::out_of_range& e) {
83020       {
83021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83022       };
83023     } catch (std::exception& e) {
83024       {
83025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83026       };
83027     } catch (...) {
83028       {
83029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83030       };
83031     }
83032   }
83033 }
83034
83035
83036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83037   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83038   Dali::Actor arg2 ;
83039   Dali::Actor *argp2 ;
83040
83041   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83042   argp2 = (Dali::Actor *)jarg2;
83043   if (!argp2) {
83044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83045     return ;
83046   }
83047   arg2 = *argp2;
83048   {
83049     try {
83050       (arg1)->Remove(arg2);
83051     } catch (std::out_of_range& e) {
83052       {
83053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83054       };
83055     } catch (std::exception& e) {
83056       {
83057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83058       };
83059     } catch (...) {
83060       {
83061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83062       };
83063     }
83064   }
83065 }
83066
83067
83068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
83069   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83070
83071   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83072   {
83073     try {
83074       (arg1)->Activate();
83075     } catch (std::out_of_range& e) {
83076       {
83077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83078       };
83079     } catch (std::exception& e) {
83080       {
83081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83082       };
83083     } catch (...) {
83084       {
83085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83086       };
83087     }
83088   }
83089 }
83090
83091
83092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
83093   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83094
83095   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83096   {
83097     try {
83098       (arg1)->ActivateOnce();
83099     } catch (std::out_of_range& e) {
83100       {
83101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83102       };
83103     } catch (std::exception& e) {
83104       {
83105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83106       };
83107     } catch (...) {
83108       {
83109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83110       };
83111     }
83112   }
83113 }
83114
83115
83116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
83117   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83118
83119   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83120   {
83121     try {
83122       (arg1)->Deactivate();
83123     } catch (std::out_of_range& e) {
83124       {
83125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83126       };
83127     } catch (std::exception& e) {
83128       {
83129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83130       };
83131     } catch (...) {
83132       {
83133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83134       };
83135     }
83136   }
83137 }
83138
83139
83140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
83141   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83142   Dali::Image arg2 ;
83143   Dali::FrameBufferImage arg3 ;
83144   Dali::Image *argp2 ;
83145   Dali::FrameBufferImage *argp3 ;
83146
83147   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83148   argp2 = (Dali::Image *)jarg2;
83149   if (!argp2) {
83150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
83151     return ;
83152   }
83153   arg2 = *argp2;
83154   argp3 = (Dali::FrameBufferImage *)jarg3;
83155   if (!argp3) {
83156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
83157     return ;
83158   }
83159   arg3 = *argp3;
83160   {
83161     try {
83162       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
83163     } catch (std::out_of_range& e) {
83164       {
83165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83166       };
83167     } catch (std::exception& e) {
83168       {
83169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83170       };
83171     } catch (...) {
83172       {
83173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83174       };
83175     }
83176   }
83177 }
83178
83179
83180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
83181   int jresult ;
83182   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83183   Dali::Property::Index result;
83184
83185   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83186   {
83187     try {
83188       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
83189     } catch (std::out_of_range& e) {
83190       {
83191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83192       };
83193     } catch (std::exception& e) {
83194       {
83195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83196       };
83197     } catch (...) {
83198       {
83199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83200       };
83201     }
83202   }
83203   jresult = result;
83204   return jresult;
83205 }
83206
83207
83208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
83209   void * jresult ;
83210   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83211   Dali::FrameBufferImage result;
83212
83213   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83214   {
83215     try {
83216       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
83217     } catch (std::out_of_range& e) {
83218       {
83219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83220       };
83221     } catch (std::exception& e) {
83222       {
83223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83224       };
83225     } catch (...) {
83226       {
83227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83228       };
83229     }
83230   }
83231   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
83232   return jresult;
83233 }
83234
83235
83236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
83237   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83238   Dali::Vector4 *arg2 = 0 ;
83239
83240   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83241   arg2 = (Dali::Vector4 *)jarg2;
83242   if (!arg2) {
83243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
83244     return ;
83245   }
83246   {
83247     try {
83248       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
83249     } catch (std::out_of_range& e) {
83250       {
83251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83252       };
83253     } catch (std::exception& e) {
83254       {
83255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83256       };
83257     } catch (...) {
83258       {
83259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83260       };
83261     }
83262   }
83263 }
83264
83265
83266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
83267   void * jresult ;
83268   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83269   Dali::Vector4 result;
83270
83271   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83272   {
83273     try {
83274       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
83275     } catch (std::out_of_range& e) {
83276       {
83277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83278       };
83279     } catch (std::exception& e) {
83280       {
83281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83282       };
83283     } catch (...) {
83284       {
83285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83286       };
83287     }
83288   }
83289   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
83290   return jresult;
83291 }
83292
83293
83294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
83295   void * jresult ;
83296   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83297   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
83298
83299   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83300   {
83301     try {
83302       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
83303     } catch (std::out_of_range& e) {
83304       {
83305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83306       };
83307     } catch (std::exception& e) {
83308       {
83309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83310       };
83311     } catch (...) {
83312       {
83313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83314       };
83315     }
83316   }
83317   jresult = (void *)result;
83318   return jresult;
83319 }
83320
83321
83322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
83323   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83324
83325   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83326   {
83327     try {
83328       delete arg1;
83329     } catch (std::out_of_range& e) {
83330       {
83331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83332       };
83333     } catch (std::exception& e) {
83334       {
83335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83336       };
83337     } catch (...) {
83338       {
83339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83340       };
83341     }
83342   }
83343 }
83344
83345
83346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
83347   unsigned int jresult ;
83348   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83349   unsigned int result;
83350
83351   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83352   {
83353     try {
83354       result = (unsigned int)(arg1)->GetNumberOfPages();
83355     } catch (std::out_of_range& e) {
83356       {
83357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83358       };
83359     } catch (std::exception& e) {
83360       {
83361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83362       };
83363     } catch (...) {
83364       {
83365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83366       };
83367     }
83368   }
83369   jresult = result;
83370   return jresult;
83371 }
83372
83373
83374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
83375   void * jresult ;
83376   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
83377   unsigned int arg2 ;
83378   Dali::Texture result;
83379
83380   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83381   arg2 = (unsigned int)jarg2;
83382   {
83383     try {
83384       result = (arg1)->NewPage(arg2);
83385     } catch (std::out_of_range& e) {
83386       {
83387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83388       };
83389     } catch (std::exception& e) {
83390       {
83391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83392       };
83393     } catch (...) {
83394       {
83395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83396       };
83397     }
83398   }
83399   jresult = new Dali::Texture((const Dali::Texture &)result);
83400   return jresult;
83401 }
83402
83403
83404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
83405   int jresult ;
83406   int result;
83407
83408   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
83409   jresult = (int)result;
83410   return jresult;
83411 }
83412
83413
83414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
83415   int jresult ;
83416   int result;
83417
83418   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
83419   jresult = (int)result;
83420   return jresult;
83421 }
83422
83423
83424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
83425   int jresult ;
83426   int result;
83427
83428   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
83429   jresult = (int)result;
83430   return jresult;
83431 }
83432
83433
83434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
83435   void * jresult ;
83436   Dali::Toolkit::PageTurnView::Property *result = 0 ;
83437
83438   {
83439     try {
83440       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
83441     } catch (std::out_of_range& e) {
83442       {
83443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83444       };
83445     } catch (std::exception& e) {
83446       {
83447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83448       };
83449     } catch (...) {
83450       {
83451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83452       };
83453     }
83454   }
83455   jresult = (void *)result;
83456   return jresult;
83457 }
83458
83459
83460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
83461   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
83462
83463   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
83464   {
83465     try {
83466       delete arg1;
83467     } catch (std::out_of_range& e) {
83468       {
83469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83470       };
83471     } catch (std::exception& e) {
83472       {
83473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83474       };
83475     } catch (...) {
83476       {
83477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83478       };
83479     }
83480   }
83481 }
83482
83483
83484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
83485   void * jresult ;
83486   Dali::Toolkit::PageTurnView *result = 0 ;
83487
83488   {
83489     try {
83490       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
83491     } catch (std::out_of_range& e) {
83492       {
83493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83494       };
83495     } catch (std::exception& e) {
83496       {
83497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83498       };
83499     } catch (...) {
83500       {
83501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83502       };
83503     }
83504   }
83505   jresult = (void *)result;
83506   return jresult;
83507 }
83508
83509
83510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
83511   void * jresult ;
83512   Dali::Toolkit::PageTurnView *arg1 = 0 ;
83513   Dali::Toolkit::PageTurnView *result = 0 ;
83514
83515   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83516   if (!arg1) {
83517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83518     return 0;
83519   }
83520   {
83521     try {
83522       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
83523     } catch (std::out_of_range& e) {
83524       {
83525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83526       };
83527     } catch (std::exception& e) {
83528       {
83529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83530       };
83531     } catch (...) {
83532       {
83533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83534       };
83535     }
83536   }
83537   jresult = (void *)result;
83538   return jresult;
83539 }
83540
83541
83542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
83543   void * jresult ;
83544   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83545   Dali::Toolkit::PageTurnView *arg2 = 0 ;
83546   Dali::Toolkit::PageTurnView *result = 0 ;
83547
83548   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83549   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
83550   if (!arg2) {
83551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
83552     return 0;
83553   }
83554   {
83555     try {
83556       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
83557     } catch (std::out_of_range& e) {
83558       {
83559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83560       };
83561     } catch (std::exception& e) {
83562       {
83563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83564       };
83565     } catch (...) {
83566       {
83567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83568       };
83569     }
83570   }
83571   jresult = (void *)result;
83572   return jresult;
83573 }
83574
83575
83576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
83577   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83578
83579   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83580   {
83581     try {
83582       delete arg1;
83583     } catch (std::out_of_range& e) {
83584       {
83585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83586       };
83587     } catch (std::exception& e) {
83588       {
83589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83590       };
83591     } catch (...) {
83592       {
83593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83594       };
83595     }
83596   }
83597 }
83598
83599
83600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
83601   void * jresult ;
83602   Dali::BaseHandle arg1 ;
83603   Dali::BaseHandle *argp1 ;
83604   Dali::Toolkit::PageTurnView result;
83605
83606   argp1 = (Dali::BaseHandle *)jarg1;
83607   if (!argp1) {
83608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83609     return 0;
83610   }
83611   arg1 = *argp1;
83612   {
83613     try {
83614       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
83615     } catch (std::out_of_range& e) {
83616       {
83617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83618       };
83619     } catch (std::exception& e) {
83620       {
83621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83622       };
83623     } catch (...) {
83624       {
83625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83626       };
83627     }
83628   }
83629   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
83630   return jresult;
83631 }
83632
83633
83634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
83635   void * jresult ;
83636   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83637   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83638
83639   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83640   {
83641     try {
83642       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
83643     } catch (std::out_of_range& e) {
83644       {
83645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83646       };
83647     } catch (std::exception& e) {
83648       {
83649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83650       };
83651     } catch (...) {
83652       {
83653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83654       };
83655     }
83656   }
83657   jresult = (void *)result;
83658   return jresult;
83659 }
83660
83661
83662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
83663   void * jresult ;
83664   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83665   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
83666
83667   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83668   {
83669     try {
83670       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
83671     } catch (std::out_of_range& e) {
83672       {
83673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83674       };
83675     } catch (std::exception& e) {
83676       {
83677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83678       };
83679     } catch (...) {
83680       {
83681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83682       };
83683     }
83684   }
83685   jresult = (void *)result;
83686   return jresult;
83687 }
83688
83689
83690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
83691   void * jresult ;
83692   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83693   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83694
83695   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83696   {
83697     try {
83698       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
83699     } catch (std::out_of_range& e) {
83700       {
83701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83702       };
83703     } catch (std::exception& e) {
83704       {
83705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83706       };
83707     } catch (...) {
83708       {
83709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83710       };
83711     }
83712   }
83713   jresult = (void *)result;
83714   return jresult;
83715 }
83716
83717
83718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
83719   void * jresult ;
83720   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
83721   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
83722
83723   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
83724   {
83725     try {
83726       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
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_new_PageTurnLandscapeView__SWIG_0() {
83747   void * jresult ;
83748   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83749
83750   {
83751     try {
83752       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
83753     } catch (std::out_of_range& e) {
83754       {
83755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83756       };
83757     } catch (std::exception& e) {
83758       {
83759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83760       };
83761     } catch (...) {
83762       {
83763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83764       };
83765     }
83766   }
83767   jresult = (void *)result;
83768   return jresult;
83769 }
83770
83771
83772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
83773   void * jresult ;
83774   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
83775   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83776
83777   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83778   if (!arg1) {
83779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83780     return 0;
83781   }
83782   {
83783     try {
83784       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
83785     } catch (std::out_of_range& e) {
83786       {
83787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83788       };
83789     } catch (std::exception& e) {
83790       {
83791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83792       };
83793     } catch (...) {
83794       {
83795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83796       };
83797     }
83798   }
83799   jresult = (void *)result;
83800   return jresult;
83801 }
83802
83803
83804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
83805   void * jresult ;
83806   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83807   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
83808   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
83809
83810   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83811   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
83812   if (!arg2) {
83813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
83814     return 0;
83815   }
83816   {
83817     try {
83818       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
83819     } catch (std::out_of_range& e) {
83820       {
83821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83822       };
83823     } catch (std::exception& e) {
83824       {
83825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83826       };
83827     } catch (...) {
83828       {
83829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83830       };
83831     }
83832   }
83833   jresult = (void *)result;
83834   return jresult;
83835 }
83836
83837
83838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
83839   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
83840
83841   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
83842   {
83843     try {
83844       delete arg1;
83845     } catch (std::out_of_range& e) {
83846       {
83847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83848       };
83849     } catch (std::exception& e) {
83850       {
83851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83852       };
83853     } catch (...) {
83854       {
83855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83856       };
83857     }
83858   }
83859 }
83860
83861
83862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
83863   void * jresult ;
83864   Dali::Toolkit::PageFactory *arg1 = 0 ;
83865   Dali::Vector2 *arg2 = 0 ;
83866   Dali::Toolkit::PageTurnLandscapeView result;
83867
83868   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
83869   if (!arg1) {
83870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
83871     return 0;
83872   }
83873   arg2 = (Dali::Vector2 *)jarg2;
83874   if (!arg2) {
83875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
83876     return 0;
83877   }
83878   {
83879     try {
83880       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
83881     } catch (std::out_of_range& e) {
83882       {
83883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83884       };
83885     } catch (std::exception& e) {
83886       {
83887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83888       };
83889     } catch (...) {
83890       {
83891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83892       };
83893     }
83894   }
83895   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83896   return jresult;
83897 }
83898
83899
83900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
83901   void * jresult ;
83902   Dali::BaseHandle arg1 ;
83903   Dali::BaseHandle *argp1 ;
83904   Dali::Toolkit::PageTurnLandscapeView result;
83905
83906   argp1 = (Dali::BaseHandle *)jarg1;
83907   if (!argp1) {
83908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83909     return 0;
83910   }
83911   arg1 = *argp1;
83912   {
83913     try {
83914       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
83915     } catch (std::out_of_range& e) {
83916       {
83917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83918       };
83919     } catch (std::exception& e) {
83920       {
83921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83922       };
83923     } catch (...) {
83924       {
83925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83926       };
83927     }
83928   }
83929   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
83930   return jresult;
83931 }
83932
83933
83934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
83935   void * jresult ;
83936   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83937
83938   {
83939     try {
83940       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
83941     } catch (std::out_of_range& e) {
83942       {
83943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83944       };
83945     } catch (std::exception& e) {
83946       {
83947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83948       };
83949     } catch (...) {
83950       {
83951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83952       };
83953     }
83954   }
83955   jresult = (void *)result;
83956   return jresult;
83957 }
83958
83959
83960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
83961   void * jresult ;
83962   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
83963   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83964
83965   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83966   if (!arg1) {
83967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
83968     return 0;
83969   }
83970   {
83971     try {
83972       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
83973     } catch (std::out_of_range& e) {
83974       {
83975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83976       };
83977     } catch (std::exception& e) {
83978       {
83979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83980       };
83981     } catch (...) {
83982       {
83983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83984       };
83985     }
83986   }
83987   jresult = (void *)result;
83988   return jresult;
83989 }
83990
83991
83992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
83993   void * jresult ;
83994   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
83995   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
83996   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
83997
83998   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
83999   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
84000   if (!arg2) {
84001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84002     return 0;
84003   }
84004   {
84005     try {
84006       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
84007     } catch (std::out_of_range& e) {
84008       {
84009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84010       };
84011     } catch (std::exception& e) {
84012       {
84013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84014       };
84015     } catch (...) {
84016       {
84017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84018       };
84019     }
84020   }
84021   jresult = (void *)result;
84022   return jresult;
84023 }
84024
84025
84026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
84027   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84028
84029   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84030   {
84031     try {
84032       delete arg1;
84033     } catch (std::out_of_range& e) {
84034       {
84035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84036       };
84037     } catch (std::exception& e) {
84038       {
84039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84040       };
84041     } catch (...) {
84042       {
84043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84044       };
84045     }
84046   }
84047 }
84048
84049
84050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
84051   void * jresult ;
84052   Dali::Toolkit::PageFactory *arg1 = 0 ;
84053   Dali::Vector2 *arg2 = 0 ;
84054   Dali::Toolkit::PageTurnPortraitView result;
84055
84056   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84057   if (!arg1) {
84058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84059     return 0;
84060   }
84061   arg2 = (Dali::Vector2 *)jarg2;
84062   if (!arg2) {
84063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84064     return 0;
84065   }
84066   {
84067     try {
84068       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
84069     } catch (std::out_of_range& e) {
84070       {
84071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84072       };
84073     } catch (std::exception& e) {
84074       {
84075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84076       };
84077     } catch (...) {
84078       {
84079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84080       };
84081     }
84082   }
84083   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84084   return jresult;
84085 }
84086
84087
84088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
84089   void * jresult ;
84090   Dali::BaseHandle arg1 ;
84091   Dali::BaseHandle *argp1 ;
84092   Dali::Toolkit::PageTurnPortraitView result;
84093
84094   argp1 = (Dali::BaseHandle *)jarg1;
84095   if (!argp1) {
84096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84097     return 0;
84098   }
84099   arg1 = *argp1;
84100   {
84101     try {
84102       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
84103     } catch (std::out_of_range& e) {
84104       {
84105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84106       };
84107     } catch (std::exception& e) {
84108       {
84109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84110       };
84111     } catch (...) {
84112       {
84113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84114       };
84115     }
84116   }
84117   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84118   return jresult;
84119 }
84120
84121
84122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
84123   int jresult ;
84124   int result;
84125
84126   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
84127   jresult = (int)result;
84128   return jresult;
84129 }
84130
84131
84132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
84133   int jresult ;
84134   int result;
84135
84136   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
84137   jresult = (int)result;
84138   return jresult;
84139 }
84140
84141
84142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
84143   int jresult ;
84144   int result;
84145
84146   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
84147   jresult = (int)result;
84148   return jresult;
84149 }
84150
84151
84152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
84153   void * jresult ;
84154   Dali::Toolkit::ToggleButton::Property *result = 0 ;
84155
84156   {
84157     try {
84158       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
84159     } catch (std::out_of_range& e) {
84160       {
84161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84162       };
84163     } catch (std::exception& e) {
84164       {
84165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84166       };
84167     } catch (...) {
84168       {
84169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84170       };
84171     }
84172   }
84173   jresult = (void *)result;
84174   return jresult;
84175 }
84176
84177
84178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
84179   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
84180
84181   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
84182   {
84183     try {
84184       delete arg1;
84185     } catch (std::out_of_range& e) {
84186       {
84187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84188       };
84189     } catch (std::exception& e) {
84190       {
84191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84192       };
84193     } catch (...) {
84194       {
84195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84196       };
84197     }
84198   }
84199 }
84200
84201
84202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
84203   void * jresult ;
84204   Dali::Toolkit::ToggleButton *result = 0 ;
84205
84206   {
84207     try {
84208       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
84209     } catch (std::out_of_range& e) {
84210       {
84211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84212       };
84213     } catch (std::exception& e) {
84214       {
84215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84216       };
84217     } catch (...) {
84218       {
84219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84220       };
84221     }
84222   }
84223   jresult = (void *)result;
84224   return jresult;
84225 }
84226
84227
84228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
84229   void * jresult ;
84230   Dali::Toolkit::ToggleButton *arg1 = 0 ;
84231   Dali::Toolkit::ToggleButton *result = 0 ;
84232
84233   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84234   if (!arg1) {
84235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84236     return 0;
84237   }
84238   {
84239     try {
84240       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
84241     } catch (std::out_of_range& e) {
84242       {
84243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84244       };
84245     } catch (std::exception& e) {
84246       {
84247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84248       };
84249     } catch (...) {
84250       {
84251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84252       };
84253     }
84254   }
84255   jresult = (void *)result;
84256   return jresult;
84257 }
84258
84259
84260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
84261   void * jresult ;
84262   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84263   Dali::Toolkit::ToggleButton *arg2 = 0 ;
84264   Dali::Toolkit::ToggleButton *result = 0 ;
84265
84266   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84267   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
84268   if (!arg2) {
84269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
84270     return 0;
84271   }
84272   {
84273     try {
84274       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
84275     } catch (std::out_of_range& e) {
84276       {
84277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84278       };
84279     } catch (std::exception& e) {
84280       {
84281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84282       };
84283     } catch (...) {
84284       {
84285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84286       };
84287     }
84288   }
84289   jresult = (void *)result;
84290   return jresult;
84291 }
84292
84293
84294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
84295   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
84296
84297   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
84298   {
84299     try {
84300       delete arg1;
84301     } catch (std::out_of_range& e) {
84302       {
84303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84304       };
84305     } catch (std::exception& e) {
84306       {
84307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84308       };
84309     } catch (...) {
84310       {
84311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84312       };
84313     }
84314   }
84315 }
84316
84317
84318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
84319   void * jresult ;
84320   Dali::Toolkit::ToggleButton result;
84321
84322   {
84323     try {
84324       result = Dali::Toolkit::ToggleButton::New();
84325     } catch (std::out_of_range& e) {
84326       {
84327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84328       };
84329     } catch (std::exception& e) {
84330       {
84331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84332       };
84333     } catch (...) {
84334       {
84335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84336       };
84337     }
84338   }
84339   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84340   return jresult;
84341 }
84342
84343
84344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
84345   void * jresult ;
84346   Dali::BaseHandle arg1 ;
84347   Dali::BaseHandle *argp1 ;
84348   Dali::Toolkit::ToggleButton result;
84349
84350   argp1 = (Dali::BaseHandle *)jarg1;
84351   if (!argp1) {
84352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84353     return 0;
84354   }
84355   arg1 = *argp1;
84356   {
84357     try {
84358       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
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 = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
84374   return jresult;
84375 }
84376
84377
84378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
84379   void * jresult ;
84380   Dali::Toolkit::Visual::Base *result = 0 ;
84381
84382   {
84383     try {
84384       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
84385     } catch (std::out_of_range& e) {
84386       {
84387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84388       };
84389     } catch (std::exception& e) {
84390       {
84391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84392       };
84393     } catch (...) {
84394       {
84395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84396       };
84397     }
84398   }
84399   jresult = (void *)result;
84400   return jresult;
84401 }
84402
84403
84404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
84405   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84406
84407   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84408   {
84409     try {
84410       delete arg1;
84411     } catch (std::out_of_range& e) {
84412       {
84413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84414       };
84415     } catch (std::exception& e) {
84416       {
84417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84418       };
84419     } catch (...) {
84420       {
84421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84422       };
84423     }
84424   }
84425 }
84426
84427
84428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
84429   void * jresult ;
84430   Dali::Toolkit::Visual::Base *arg1 = 0 ;
84431   Dali::Toolkit::Visual::Base *result = 0 ;
84432
84433   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84434   if (!arg1) {
84435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84436     return 0;
84437   }
84438   {
84439     try {
84440       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
84441     } catch (std::out_of_range& e) {
84442       {
84443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84444       };
84445     } catch (std::exception& e) {
84446       {
84447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84448       };
84449     } catch (...) {
84450       {
84451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84452       };
84453     }
84454   }
84455   jresult = (void *)result;
84456   return jresult;
84457 }
84458
84459
84460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
84461   void * jresult ;
84462   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84463   Dali::Toolkit::Visual::Base *arg2 = 0 ;
84464   Dali::Toolkit::Visual::Base *result = 0 ;
84465
84466   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84467   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
84468   if (!arg2) {
84469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
84470     return 0;
84471   }
84472   {
84473     try {
84474       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
84475     } catch (std::out_of_range& e) {
84476       {
84477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84478       };
84479     } catch (std::exception& e) {
84480       {
84481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84482       };
84483     } catch (...) {
84484       {
84485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84486       };
84487     }
84488   }
84489   jresult = (void *)result;
84490   return jresult;
84491 }
84492
84493
84494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
84495   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84496   std::string *arg2 = 0 ;
84497
84498   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84499   if (!jarg2) {
84500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84501     return ;
84502   }
84503   std::string arg2_str(jarg2);
84504   arg2 = &arg2_str;
84505   {
84506     try {
84507       (arg1)->SetName((std::string const &)*arg2);
84508     } catch (std::out_of_range& e) {
84509       {
84510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84511       };
84512     } catch (std::exception& e) {
84513       {
84514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84515       };
84516     } catch (...) {
84517       {
84518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84519       };
84520     }
84521   }
84522
84523   //argout typemap for const std::string&
84524
84525 }
84526
84527
84528 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
84529   char * jresult ;
84530   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84531   std::string *result = 0 ;
84532
84533   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84534   {
84535     try {
84536       result = (std::string *) &(arg1)->GetName();
84537     } catch (std::out_of_range& e) {
84538       {
84539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84540       };
84541     } catch (std::exception& e) {
84542       {
84543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84544       };
84545     } catch (...) {
84546       {
84547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84548       };
84549     }
84550   }
84551   jresult = SWIG_csharp_string_callback(result->c_str());
84552   return jresult;
84553 }
84554
84555
84556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
84557   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84558   Dali::Property::Map *arg2 = 0 ;
84559   Dali::Size arg3 ;
84560   Dali::Size *argp3 ;
84561
84562   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84563   arg2 = (Dali::Property::Map *)jarg2;
84564   if (!arg2) {
84565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84566     return ;
84567   }
84568   argp3 = (Dali::Size *)jarg3;
84569   if (!argp3) {
84570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
84571     return ;
84572   }
84573   arg3 = *argp3;
84574   {
84575     try {
84576       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
84577     } catch (std::out_of_range& e) {
84578       {
84579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84580       };
84581     } catch (std::exception& e) {
84582       {
84583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84584       };
84585     } catch (...) {
84586       {
84587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84588       };
84589     }
84590   }
84591 }
84592
84593
84594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
84595   float jresult ;
84596   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84597   float arg2 ;
84598   float result;
84599
84600   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84601   arg2 = (float)jarg2;
84602   {
84603     try {
84604       result = (float)(arg1)->GetHeightForWidth(arg2);
84605     } catch (std::out_of_range& e) {
84606       {
84607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84608       };
84609     } catch (std::exception& e) {
84610       {
84611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84612       };
84613     } catch (...) {
84614       {
84615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84616       };
84617     }
84618   }
84619   jresult = result;
84620   return jresult;
84621 }
84622
84623
84624 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
84625   float jresult ;
84626   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84627   float arg2 ;
84628   float result;
84629
84630   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84631   arg2 = (float)jarg2;
84632   {
84633     try {
84634       result = (float)(arg1)->GetWidthForHeight(arg2);
84635     } catch (std::out_of_range& e) {
84636       {
84637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84638       };
84639     } catch (std::exception& e) {
84640       {
84641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84642       };
84643     } catch (...) {
84644       {
84645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84646       };
84647     }
84648   }
84649   jresult = result;
84650   return jresult;
84651 }
84652
84653
84654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
84655   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84656   Dali::Vector2 *arg2 = 0 ;
84657
84658   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84659   arg2 = (Dali::Vector2 *)jarg2;
84660   if (!arg2) {
84661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
84662     return ;
84663   }
84664   {
84665     try {
84666       (arg1)->GetNaturalSize(*arg2);
84667     } catch (std::out_of_range& e) {
84668       {
84669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84670       };
84671     } catch (std::exception& e) {
84672       {
84673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84674       };
84675     } catch (...) {
84676       {
84677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84678       };
84679     }
84680   }
84681 }
84682
84683
84684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, float jarg2) {
84685   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84686   float arg2 ;
84687
84688   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84689   arg2 = (float)jarg2;
84690   {
84691     try {
84692       (arg1)->SetDepthIndex(arg2);
84693     } catch (std::out_of_range& e) {
84694       {
84695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84696       };
84697     } catch (std::exception& e) {
84698       {
84699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84700       };
84701     } catch (...) {
84702       {
84703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84704       };
84705     }
84706   }
84707 }
84708
84709
84710 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
84711   float jresult ;
84712   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84713   float result;
84714
84715   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84716   {
84717     try {
84718       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
84719     } catch (std::out_of_range& e) {
84720       {
84721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84722       };
84723     } catch (std::exception& e) {
84724       {
84725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84726       };
84727     } catch (...) {
84728       {
84729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84730       };
84731     }
84732   }
84733   jresult = result;
84734   return jresult;
84735 }
84736
84737
84738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
84739   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
84740   Dali::Property::Map *arg2 = 0 ;
84741
84742   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
84743   arg2 = (Dali::Property::Map *)jarg2;
84744   if (!arg2) {
84745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
84746     return ;
84747   }
84748   {
84749     try {
84750       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
84751     } catch (std::out_of_range& e) {
84752       {
84753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84754       };
84755     } catch (std::exception& e) {
84756       {
84757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84758       };
84759     } catch (...) {
84760       {
84761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84762       };
84763     }
84764   }
84765 }
84766
84767
84768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
84769   void * jresult ;
84770   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
84771   Dali::Toolkit::Visual::Base *result = 0 ;
84772
84773   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
84774   {
84775     try {
84776       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
84777     } catch (std::out_of_range& e) {
84778       {
84779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84780       };
84781     } catch (std::exception& e) {
84782       {
84783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84784       };
84785     } catch (...) {
84786       {
84787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84788       };
84789     }
84790   }
84791   jresult = (void *)result;
84792   return jresult;
84793 }
84794
84795
84796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
84797   void * jresult ;
84798   Dali::Toolkit::VisualFactory result;
84799
84800   {
84801     try {
84802       result = Dali::Toolkit::VisualFactory::Get();
84803     } catch (std::out_of_range& e) {
84804       {
84805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84806       };
84807     } catch (std::exception& e) {
84808       {
84809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84810       };
84811     } catch (...) {
84812       {
84813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84814       };
84815     }
84816   }
84817   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
84818   return jresult;
84819 }
84820
84821
84822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
84823   void * jresult ;
84824   Dali::Toolkit::VisualFactory *result = 0 ;
84825
84826   {
84827     try {
84828       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
84829     } catch (std::out_of_range& e) {
84830       {
84831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84832       };
84833     } catch (std::exception& e) {
84834       {
84835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84836       };
84837     } catch (...) {
84838       {
84839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84840       };
84841     }
84842   }
84843   jresult = (void *)result;
84844   return jresult;
84845 }
84846
84847
84848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
84849   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84850
84851   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84852   {
84853     try {
84854       delete arg1;
84855     } catch (std::out_of_range& e) {
84856       {
84857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84858       };
84859     } catch (std::exception& e) {
84860       {
84861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84862       };
84863     } catch (...) {
84864       {
84865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84866       };
84867     }
84868   }
84869 }
84870
84871
84872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
84873   void * jresult ;
84874   Dali::Toolkit::VisualFactory *arg1 = 0 ;
84875   Dali::Toolkit::VisualFactory *result = 0 ;
84876
84877   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84878   if (!arg1) {
84879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84880     return 0;
84881   }
84882   {
84883     try {
84884       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
84885     } catch (std::out_of_range& e) {
84886       {
84887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84888       };
84889     } catch (std::exception& e) {
84890       {
84891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84892       };
84893     } catch (...) {
84894       {
84895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84896       };
84897     }
84898   }
84899   jresult = (void *)result;
84900   return jresult;
84901 }
84902
84903
84904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
84905   void * jresult ;
84906   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84907   Dali::Toolkit::VisualFactory *arg2 = 0 ;
84908   Dali::Toolkit::VisualFactory *result = 0 ;
84909
84910   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84911   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
84912   if (!arg2) {
84913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
84914     return 0;
84915   }
84916   {
84917     try {
84918       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
84919     } catch (std::out_of_range& e) {
84920       {
84921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84922       };
84923     } catch (std::exception& e) {
84924       {
84925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84926       };
84927     } catch (...) {
84928       {
84929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84930       };
84931     }
84932   }
84933   jresult = (void *)result;
84934   return jresult;
84935 }
84936
84937
84938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
84939   void * jresult ;
84940   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84941   Dali::Property::Map *arg2 = 0 ;
84942   Dali::Toolkit::Visual::Base result;
84943
84944   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84945   arg2 = (Dali::Property::Map *)jarg2;
84946   if (!arg2) {
84947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
84948     return 0;
84949   }
84950   {
84951     try {
84952       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
84953     } catch (std::out_of_range& e) {
84954       {
84955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84956       };
84957     } catch (std::exception& e) {
84958       {
84959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84960       };
84961     } catch (...) {
84962       {
84963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84964       };
84965     }
84966   }
84967   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
84968   return jresult;
84969 }
84970
84971
84972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
84973   void * jresult ;
84974   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
84975   Dali::Image *arg2 = 0 ;
84976   Dali::Toolkit::Visual::Base result;
84977
84978   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
84979   arg2 = (Dali::Image *)jarg2;
84980   if (!arg2) {
84981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
84982     return 0;
84983   }
84984   {
84985     try {
84986       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
84987     } catch (std::out_of_range& e) {
84988       {
84989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84990       };
84991     } catch (std::exception& e) {
84992       {
84993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84994       };
84995     } catch (...) {
84996       {
84997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84998       };
84999     }
85000   }
85001   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85002   return jresult;
85003 }
85004
85005
85006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
85007   void * jresult ;
85008   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85009   std::string *arg2 = 0 ;
85010   Dali::ImageDimensions arg3 ;
85011   Dali::ImageDimensions *argp3 ;
85012   Dali::Toolkit::Visual::Base result;
85013
85014   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85015   if (!jarg2) {
85016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85017     return 0;
85018   }
85019   std::string arg2_str(jarg2);
85020   arg2 = &arg2_str;
85021   argp3 = (Dali::ImageDimensions *)jarg3;
85022   if (!argp3) {
85023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85024     return 0;
85025   }
85026   arg3 = *argp3;
85027   {
85028     try {
85029       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
85030     } catch (std::out_of_range& e) {
85031       {
85032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85033       };
85034     } catch (std::exception& e) {
85035       {
85036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85037       };
85038     } catch (...) {
85039       {
85040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85041       };
85042     }
85043   }
85044   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85045
85046   //argout typemap for const std::string&
85047
85048   return jresult;
85049 }
85050
85051
85052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
85053   void * jresult ;
85054   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85055
85056   {
85057     try {
85058       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
85059     } catch (std::out_of_range& e) {
85060       {
85061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85062       };
85063     } catch (std::exception& e) {
85064       {
85065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85066       };
85067     } catch (...) {
85068       {
85069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85070       };
85071     }
85072   }
85073   jresult = (void *)result;
85074   return jresult;
85075 }
85076
85077
85078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
85079   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85080
85081   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85082   {
85083     try {
85084       delete arg1;
85085     } catch (std::out_of_range& e) {
85086       {
85087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85088       };
85089     } catch (std::exception& e) {
85090       {
85091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85092       };
85093     } catch (...) {
85094       {
85095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85096       };
85097     }
85098   }
85099 }
85100
85101
85102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
85103   void * jresult ;
85104   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
85105   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85106
85107   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85108   if (!arg1) {
85109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85110     return 0;
85111   }
85112   {
85113     try {
85114       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
85115     } catch (std::out_of_range& e) {
85116       {
85117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85118       };
85119     } catch (std::exception& e) {
85120       {
85121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85122       };
85123     } catch (...) {
85124       {
85125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85126       };
85127     }
85128   }
85129   jresult = (void *)result;
85130   return jresult;
85131 }
85132
85133
85134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
85135   void * jresult ;
85136   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85137   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
85138   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85139
85140   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85141   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
85142   if (!arg2) {
85143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
85144     return 0;
85145   }
85146   {
85147     try {
85148       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
85149     } catch (std::out_of_range& e) {
85150       {
85151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85152       };
85153     } catch (std::exception& e) {
85154       {
85155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85156       };
85157     } catch (...) {
85158       {
85159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85160       };
85161     }
85162   }
85163   jresult = (void *)result;
85164   return jresult;
85165 }
85166
85167
85168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
85169   void * jresult ;
85170   Dali::Toolkit::AsyncImageLoader result;
85171
85172   {
85173     try {
85174       result = Dali::Toolkit::AsyncImageLoader::New();
85175     } catch (std::out_of_range& e) {
85176       {
85177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85178       };
85179     } catch (std::exception& e) {
85180       {
85181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85182       };
85183     } catch (...) {
85184       {
85185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85186       };
85187     }
85188   }
85189   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85190   return jresult;
85191 }
85192
85193
85194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
85195   void * jresult ;
85196   Dali::BaseHandle arg1 ;
85197   Dali::BaseHandle *argp1 ;
85198   Dali::Toolkit::AsyncImageLoader result;
85199
85200   argp1 = (Dali::BaseHandle *)jarg1;
85201   if (!argp1) {
85202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85203     return 0;
85204   }
85205   arg1 = *argp1;
85206   {
85207     try {
85208       result = Dali::Toolkit::AsyncImageLoader::DownCast(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 = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
85224   return jresult;
85225 }
85226
85227
85228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
85229   unsigned int jresult ;
85230   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85231   std::string *arg2 = 0 ;
85232   uint32_t result;
85233
85234   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85235   if (!jarg2) {
85236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85237     return 0;
85238   }
85239   std::string arg2_str(jarg2);
85240   arg2 = &arg2_str;
85241   {
85242     try {
85243       result = (arg1)->Load((std::string const &)*arg2);
85244     } catch (std::out_of_range& e) {
85245       {
85246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85247       };
85248     } catch (std::exception& e) {
85249       {
85250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85251       };
85252     } catch (...) {
85253       {
85254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85255       };
85256     }
85257   }
85258   jresult = result;
85259
85260   //argout typemap for const std::string&
85261
85262   return jresult;
85263 }
85264
85265
85266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
85267   unsigned int jresult ;
85268   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85269   std::string *arg2 = 0 ;
85270   Dali::ImageDimensions arg3 ;
85271   Dali::ImageDimensions *argp3 ;
85272   uint32_t result;
85273
85274   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85275   if (!jarg2) {
85276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85277     return 0;
85278   }
85279   std::string arg2_str(jarg2);
85280   arg2 = &arg2_str;
85281   argp3 = (Dali::ImageDimensions *)jarg3;
85282   if (!argp3) {
85283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85284     return 0;
85285   }
85286   arg3 = *argp3;
85287   {
85288     try {
85289       result = (arg1)->Load((std::string const &)*arg2,arg3);
85290     } catch (std::out_of_range& e) {
85291       {
85292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85293       };
85294     } catch (std::exception& e) {
85295       {
85296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85297       };
85298     } catch (...) {
85299       {
85300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85301       };
85302     }
85303   }
85304   jresult = result;
85305
85306   //argout typemap for const std::string&
85307
85308   return jresult;
85309 }
85310
85311
85312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
85313   unsigned int jresult ;
85314   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85315   std::string *arg2 = 0 ;
85316   Dali::ImageDimensions arg3 ;
85317   Dali::FittingMode::Type arg4 ;
85318   Dali::SamplingMode::Type arg5 ;
85319   bool arg6 ;
85320   Dali::ImageDimensions *argp3 ;
85321   uint32_t result;
85322
85323   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85324   if (!jarg2) {
85325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85326     return 0;
85327   }
85328   std::string arg2_str(jarg2);
85329   arg2 = &arg2_str;
85330   argp3 = (Dali::ImageDimensions *)jarg3;
85331   if (!argp3) {
85332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85333     return 0;
85334   }
85335   arg3 = *argp3;
85336   arg4 = (Dali::FittingMode::Type)jarg4;
85337   arg5 = (Dali::SamplingMode::Type)jarg5;
85338   arg6 = jarg6 ? true : false;
85339   {
85340     try {
85341       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
85342     } catch (std::out_of_range& e) {
85343       {
85344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85345       };
85346     } catch (std::exception& e) {
85347       {
85348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85349       };
85350     } catch (...) {
85351       {
85352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85353       };
85354     }
85355   }
85356   jresult = result;
85357
85358   //argout typemap for const std::string&
85359
85360   return jresult;
85361 }
85362
85363
85364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
85365   unsigned int jresult ;
85366   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85367   uint32_t arg2 ;
85368   bool result;
85369
85370   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85371   arg2 = (uint32_t)jarg2;
85372   {
85373     try {
85374       result = (bool)(arg1)->Cancel(arg2);
85375     } catch (std::out_of_range& e) {
85376       {
85377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85378       };
85379     } catch (std::exception& e) {
85380       {
85381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85382       };
85383     } catch (...) {
85384       {
85385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85386       };
85387     }
85388   }
85389   jresult = result;
85390   return jresult;
85391 }
85392
85393
85394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
85395   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85396
85397   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85398   {
85399     try {
85400       (arg1)->CancelAll();
85401     } catch (std::out_of_range& e) {
85402       {
85403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85404       };
85405     } catch (std::exception& e) {
85406       {
85407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85408       };
85409     } catch (...) {
85410       {
85411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85412       };
85413     }
85414   }
85415 }
85416
85417
85418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
85419   void * jresult ;
85420   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
85421   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
85422
85423   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
85424   {
85425     try {
85426       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
85427     } catch (std::out_of_range& e) {
85428       {
85429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85430       };
85431     } catch (std::exception& e) {
85432       {
85433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85434       };
85435     } catch (...) {
85436       {
85437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85438       };
85439     }
85440   }
85441   jresult = (void *)result;
85442   return jresult;
85443 }
85444
85445
85446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
85447   void * jresult ;
85448   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
85449   Dali::Toolkit::AsyncImageLoader *result = 0 ;
85450
85451   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
85452   {
85453     try {
85454       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
85455     } catch (std::out_of_range& e) {
85456       {
85457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85458       };
85459     } catch (std::exception& e) {
85460       {
85461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85462       };
85463     } catch (...) {
85464       {
85465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85466       };
85467     }
85468   }
85469   jresult = (void *)result;
85470   return jresult;
85471 }
85472
85473
85474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
85475   void * jresult ;
85476   std::string *arg1 = 0 ;
85477   Dali::PixelData result;
85478
85479   if (!jarg1) {
85480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85481     return 0;
85482   }
85483   std::string arg1_str(jarg1);
85484   arg1 = &arg1_str;
85485   {
85486     try {
85487       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
85488     } catch (std::out_of_range& e) {
85489       {
85490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85491       };
85492     } catch (std::exception& e) {
85493       {
85494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85495       };
85496     } catch (...) {
85497       {
85498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85499       };
85500     }
85501   }
85502   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85503
85504   //argout typemap for const std::string&
85505
85506   return jresult;
85507 }
85508
85509
85510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
85511   void * jresult ;
85512   std::string *arg1 = 0 ;
85513   Dali::ImageDimensions arg2 ;
85514   Dali::ImageDimensions *argp2 ;
85515   Dali::PixelData result;
85516
85517   if (!jarg1) {
85518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85519     return 0;
85520   }
85521   std::string arg1_str(jarg1);
85522   arg1 = &arg1_str;
85523   argp2 = (Dali::ImageDimensions *)jarg2;
85524   if (!argp2) {
85525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85526     return 0;
85527   }
85528   arg2 = *argp2;
85529   {
85530     try {
85531       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
85532     } catch (std::out_of_range& e) {
85533       {
85534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85535       };
85536     } catch (std::exception& e) {
85537       {
85538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85539       };
85540     } catch (...) {
85541       {
85542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85543       };
85544     }
85545   }
85546   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85547
85548   //argout typemap for const std::string&
85549
85550   return jresult;
85551 }
85552
85553
85554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
85555   void * jresult ;
85556   std::string *arg1 = 0 ;
85557   Dali::ImageDimensions arg2 ;
85558   Dali::FittingMode::Type arg3 ;
85559   Dali::SamplingMode::Type arg4 ;
85560   bool arg5 ;
85561   Dali::ImageDimensions *argp2 ;
85562   Dali::PixelData result;
85563
85564   if (!jarg1) {
85565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85566     return 0;
85567   }
85568   std::string arg1_str(jarg1);
85569   arg1 = &arg1_str;
85570   argp2 = (Dali::ImageDimensions *)jarg2;
85571   if (!argp2) {
85572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
85573     return 0;
85574   }
85575   arg2 = *argp2;
85576   arg3 = (Dali::FittingMode::Type)jarg3;
85577   arg4 = (Dali::SamplingMode::Type)jarg4;
85578   arg5 = jarg5 ? true : false;
85579   {
85580     try {
85581       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
85582     } catch (std::out_of_range& e) {
85583       {
85584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85585       };
85586     } catch (std::exception& e) {
85587       {
85588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85589       };
85590     } catch (...) {
85591       {
85592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85593       };
85594     }
85595   }
85596   jresult = new Dali::PixelData((const Dali::PixelData &)result);
85597
85598   //argout typemap for const std::string&
85599
85600   return jresult;
85601 }
85602
85603
85604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
85605   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85606
85607   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85608   {
85609     try {
85610       delete arg1;
85611     } catch (std::out_of_range& e) {
85612       {
85613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85614       };
85615     } catch (std::exception& e) {
85616       {
85617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85618       };
85619     } catch (...) {
85620       {
85621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85622       };
85623     }
85624   }
85625 }
85626
85627
85628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
85629   void * jresult ;
85630   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
85631   Dali::Actor arg2 ;
85632   Dali::Actor arg3 ;
85633   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
85634   Dali::Actor *argp2 ;
85635   Dali::Actor *argp3 ;
85636   Dali::Actor result;
85637
85638   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
85639   argp2 = (Dali::Actor *)jarg2;
85640   if (!argp2) {
85641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85642     return 0;
85643   }
85644   arg2 = *argp2;
85645   argp3 = (Dali::Actor *)jarg3;
85646   if (!argp3) {
85647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85648     return 0;
85649   }
85650   arg3 = *argp3;
85651   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
85652   {
85653     try {
85654       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
85655     } catch (std::out_of_range& e) {
85656       {
85657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85658       };
85659     } catch (std::exception& e) {
85660       {
85661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85662       };
85663     } catch (...) {
85664       {
85665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85666       };
85667     }
85668   }
85669   jresult = new Dali::Actor((const Dali::Actor &)result);
85670   return jresult;
85671 }
85672
85673
85674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
85675   void * jresult ;
85676   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
85677
85678   {
85679     try {
85680       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
85681     } catch (std::out_of_range& e) {
85682       {
85683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85684       };
85685     } catch (std::exception& e) {
85686       {
85687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85688       };
85689     } catch (...) {
85690       {
85691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85692       };
85693     }
85694   }
85695   jresult = (void *)result;
85696   return jresult;
85697 }
85698
85699
85700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
85701   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
85702   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
85703   if (director) {
85704     director->swig_connect_director(callback0);
85705   }
85706 }
85707
85708
85709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
85710   KeyboardFocusManager arg1 ;
85711   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
85712   KeyboardFocusManager *argp1 ;
85713
85714   argp1 = (KeyboardFocusManager *)jarg1;
85715   if (!argp1) {
85716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
85717     return ;
85718   }
85719   arg1 = *argp1;
85720   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
85721   if (!arg2) {
85722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
85723     return ;
85724   }
85725   {
85726     try {
85727       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
85728     } catch (std::out_of_range& e) {
85729       {
85730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85731       };
85732     } catch (std::exception& e) {
85733       {
85734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85735       };
85736     } catch (...) {
85737       {
85738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85739       };
85740     }
85741   }
85742 }
85743
85744
85745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
85746   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85747
85748   arg1 = (std::vector< unsigned int > *)jarg1;
85749   {
85750     try {
85751       (arg1)->clear();
85752     } catch (std::out_of_range& e) {
85753       {
85754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85755       };
85756     } catch (std::exception& e) {
85757       {
85758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85759       };
85760     } catch (...) {
85761       {
85762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85763       };
85764     }
85765   }
85766 }
85767
85768
85769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
85770   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85771   unsigned int *arg2 = 0 ;
85772   unsigned int temp2 ;
85773
85774   arg1 = (std::vector< unsigned int > *)jarg1;
85775   temp2 = (unsigned int)jarg2;
85776   arg2 = &temp2;
85777   {
85778     try {
85779       (arg1)->push_back((unsigned int const &)*arg2);
85780     } catch (std::out_of_range& e) {
85781       {
85782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85783       };
85784     } catch (std::exception& e) {
85785       {
85786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85787       };
85788     } catch (...) {
85789       {
85790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85791       };
85792     }
85793   }
85794 }
85795
85796
85797 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
85798   unsigned long jresult ;
85799   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85800   std::vector< unsigned int >::size_type result;
85801
85802   arg1 = (std::vector< unsigned int > *)jarg1;
85803   {
85804     try {
85805       result = ((std::vector< unsigned int > const *)arg1)->size();
85806     } catch (std::out_of_range& e) {
85807       {
85808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85809       };
85810     } catch (std::exception& e) {
85811       {
85812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85813       };
85814     } catch (...) {
85815       {
85816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85817       };
85818     }
85819   }
85820   jresult = (unsigned long)result;
85821   return jresult;
85822 }
85823
85824
85825 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
85826   unsigned long jresult ;
85827   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85828   std::vector< unsigned int >::size_type result;
85829
85830   arg1 = (std::vector< unsigned int > *)jarg1;
85831   {
85832     try {
85833       result = ((std::vector< unsigned int > const *)arg1)->capacity();
85834     } catch (std::out_of_range& e) {
85835       {
85836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85837       };
85838     } catch (std::exception& e) {
85839       {
85840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85841       };
85842     } catch (...) {
85843       {
85844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85845       };
85846     }
85847   }
85848   jresult = (unsigned long)result;
85849   return jresult;
85850 }
85851
85852
85853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
85854   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85855   std::vector< unsigned int >::size_type arg2 ;
85856
85857   arg1 = (std::vector< unsigned int > *)jarg1;
85858   arg2 = (std::vector< unsigned int >::size_type)jarg2;
85859   {
85860     try {
85861       (arg1)->reserve(arg2);
85862     } catch (std::out_of_range& e) {
85863       {
85864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85865       };
85866     } catch (std::exception& e) {
85867       {
85868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85869       };
85870     } catch (...) {
85871       {
85872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85873       };
85874     }
85875   }
85876 }
85877
85878
85879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
85880   void * jresult ;
85881   std::vector< unsigned int > *result = 0 ;
85882
85883   {
85884     try {
85885       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
85886     } catch (std::out_of_range& e) {
85887       {
85888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85889       };
85890     } catch (std::exception& e) {
85891       {
85892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85893       };
85894     } catch (...) {
85895       {
85896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85897       };
85898     }
85899   }
85900   jresult = (void *)result;
85901   return jresult;
85902 }
85903
85904
85905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
85906   void * jresult ;
85907   std::vector< unsigned int > *arg1 = 0 ;
85908   std::vector< unsigned int > *result = 0 ;
85909
85910   arg1 = (std::vector< unsigned int > *)jarg1;
85911   if (!arg1) {
85912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
85913     return 0;
85914   }
85915   {
85916     try {
85917       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
85918     } catch (std::out_of_range& e) {
85919       {
85920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85921       };
85922     } catch (std::exception& e) {
85923       {
85924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85925       };
85926     } catch (...) {
85927       {
85928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85929       };
85930     }
85931   }
85932   jresult = (void *)result;
85933   return jresult;
85934 }
85935
85936
85937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
85938   void * jresult ;
85939   int arg1 ;
85940   std::vector< unsigned int > *result = 0 ;
85941
85942   arg1 = (int)jarg1;
85943   {
85944     try {
85945       try {
85946         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
85947       }
85948       catch(std::out_of_range &_e) {
85949         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85950         return 0;
85951       }
85952
85953     } catch (std::out_of_range& e) {
85954       {
85955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85956       };
85957     } catch (std::exception& e) {
85958       {
85959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85960       };
85961     } catch (...) {
85962       {
85963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85964       };
85965     }
85966   }
85967   jresult = (void *)result;
85968   return jresult;
85969 }
85970
85971
85972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
85973   unsigned int jresult ;
85974   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
85975   int arg2 ;
85976   unsigned int result;
85977
85978   arg1 = (std::vector< unsigned int > *)jarg1;
85979   arg2 = (int)jarg2;
85980   {
85981     try {
85982       try {
85983         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
85984       }
85985       catch(std::out_of_range &_e) {
85986         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
85987         return 0;
85988       }
85989
85990     } catch (std::out_of_range& e) {
85991       {
85992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85993       };
85994     } catch (std::exception& e) {
85995       {
85996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85997       };
85998     } catch (...) {
85999       {
86000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86001       };
86002     }
86003   }
86004   jresult = result;
86005   return jresult;
86006 }
86007
86008
86009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
86010   unsigned int jresult ;
86011   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86012   int arg2 ;
86013   unsigned int *result = 0 ;
86014
86015   arg1 = (std::vector< unsigned int > *)jarg1;
86016   arg2 = (int)jarg2;
86017   {
86018     try {
86019       try {
86020         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
86021       }
86022       catch(std::out_of_range &_e) {
86023         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86024         return 0;
86025       }
86026
86027     } catch (std::out_of_range& e) {
86028       {
86029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86030       };
86031     } catch (std::exception& e) {
86032       {
86033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86034       };
86035     } catch (...) {
86036       {
86037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86038       };
86039     }
86040   }
86041   jresult = *result;
86042   return jresult;
86043 }
86044
86045
86046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
86047   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86048   int arg2 ;
86049   unsigned int *arg3 = 0 ;
86050   unsigned int temp3 ;
86051
86052   arg1 = (std::vector< unsigned int > *)jarg1;
86053   arg2 = (int)jarg2;
86054   temp3 = (unsigned int)jarg3;
86055   arg3 = &temp3;
86056   {
86057     try {
86058       try {
86059         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
86060       }
86061       catch(std::out_of_range &_e) {
86062         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86063         return ;
86064       }
86065
86066     } catch (std::out_of_range& e) {
86067       {
86068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86069       };
86070     } catch (std::exception& e) {
86071       {
86072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86073       };
86074     } catch (...) {
86075       {
86076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86077       };
86078     }
86079   }
86080 }
86081
86082
86083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
86084   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86085   std::vector< unsigned int > *arg2 = 0 ;
86086
86087   arg1 = (std::vector< unsigned int > *)jarg1;
86088   arg2 = (std::vector< unsigned int > *)jarg2;
86089   if (!arg2) {
86090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86091     return ;
86092   }
86093   {
86094     try {
86095       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
86096     } catch (std::out_of_range& e) {
86097       {
86098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86099       };
86100     } catch (std::exception& e) {
86101       {
86102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86103       };
86104     } catch (...) {
86105       {
86106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86107       };
86108     }
86109   }
86110 }
86111
86112
86113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
86114   void * jresult ;
86115   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86116   int arg2 ;
86117   int arg3 ;
86118   std::vector< unsigned int > *result = 0 ;
86119
86120   arg1 = (std::vector< unsigned int > *)jarg1;
86121   arg2 = (int)jarg2;
86122   arg3 = (int)jarg3;
86123   {
86124     try {
86125       try {
86126         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
86127       }
86128       catch(std::out_of_range &_e) {
86129         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86130         return 0;
86131       }
86132       catch(std::invalid_argument &_e) {
86133         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86134         return 0;
86135       }
86136
86137     } catch (std::out_of_range& e) {
86138       {
86139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86140       };
86141     } catch (std::exception& e) {
86142       {
86143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86144       };
86145     } catch (...) {
86146       {
86147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86148       };
86149     }
86150   }
86151   jresult = (void *)result;
86152   return jresult;
86153 }
86154
86155
86156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
86157   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86158   int arg2 ;
86159   unsigned int *arg3 = 0 ;
86160   unsigned int temp3 ;
86161
86162   arg1 = (std::vector< unsigned int > *)jarg1;
86163   arg2 = (int)jarg2;
86164   temp3 = (unsigned int)jarg3;
86165   arg3 = &temp3;
86166   {
86167     try {
86168       try {
86169         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
86170       }
86171       catch(std::out_of_range &_e) {
86172         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86173         return ;
86174       }
86175
86176     } catch (std::out_of_range& e) {
86177       {
86178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86179       };
86180     } catch (std::exception& e) {
86181       {
86182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86183       };
86184     } catch (...) {
86185       {
86186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86187       };
86188     }
86189   }
86190 }
86191
86192
86193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
86194   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86195   int arg2 ;
86196   std::vector< unsigned int > *arg3 = 0 ;
86197
86198   arg1 = (std::vector< unsigned int > *)jarg1;
86199   arg2 = (int)jarg2;
86200   arg3 = (std::vector< unsigned int > *)jarg3;
86201   if (!arg3) {
86202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86203     return ;
86204   }
86205   {
86206     try {
86207       try {
86208         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86209       }
86210       catch(std::out_of_range &_e) {
86211         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86212         return ;
86213       }
86214
86215     } catch (std::out_of_range& e) {
86216       {
86217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86218       };
86219     } catch (std::exception& e) {
86220       {
86221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86222       };
86223     } catch (...) {
86224       {
86225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86226       };
86227     }
86228   }
86229 }
86230
86231
86232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
86233   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86234   int arg2 ;
86235
86236   arg1 = (std::vector< unsigned int > *)jarg1;
86237   arg2 = (int)jarg2;
86238   {
86239     try {
86240       try {
86241         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
86242       }
86243       catch(std::out_of_range &_e) {
86244         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86245         return ;
86246       }
86247
86248     } catch (std::out_of_range& e) {
86249       {
86250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86251       };
86252     } catch (std::exception& e) {
86253       {
86254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86255       };
86256     } catch (...) {
86257       {
86258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86259       };
86260     }
86261   }
86262 }
86263
86264
86265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
86266   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86267   int arg2 ;
86268   int arg3 ;
86269
86270   arg1 = (std::vector< unsigned int > *)jarg1;
86271   arg2 = (int)jarg2;
86272   arg3 = (int)jarg3;
86273   {
86274     try {
86275       try {
86276         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
86277       }
86278       catch(std::out_of_range &_e) {
86279         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86280         return ;
86281       }
86282       catch(std::invalid_argument &_e) {
86283         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86284         return ;
86285       }
86286
86287     } catch (std::out_of_range& e) {
86288       {
86289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86290       };
86291     } catch (std::exception& e) {
86292       {
86293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86294       };
86295     } catch (...) {
86296       {
86297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86298       };
86299     }
86300   }
86301 }
86302
86303
86304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
86305   void * jresult ;
86306   unsigned int *arg1 = 0 ;
86307   int arg2 ;
86308   unsigned int temp1 ;
86309   std::vector< unsigned int > *result = 0 ;
86310
86311   temp1 = (unsigned int)jarg1;
86312   arg1 = &temp1;
86313   arg2 = (int)jarg2;
86314   {
86315     try {
86316       try {
86317         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
86318       }
86319       catch(std::out_of_range &_e) {
86320         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86321         return 0;
86322       }
86323
86324     } catch (std::out_of_range& e) {
86325       {
86326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86327       };
86328     } catch (std::exception& e) {
86329       {
86330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86331       };
86332     } catch (...) {
86333       {
86334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86335       };
86336     }
86337   }
86338   jresult = (void *)result;
86339   return jresult;
86340 }
86341
86342
86343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
86344   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86345
86346   arg1 = (std::vector< unsigned int > *)jarg1;
86347   {
86348     try {
86349       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
86350     } catch (std::out_of_range& e) {
86351       {
86352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86353       };
86354     } catch (std::exception& e) {
86355       {
86356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86357       };
86358     } catch (...) {
86359       {
86360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86361       };
86362     }
86363   }
86364 }
86365
86366
86367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
86368   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86369   int arg2 ;
86370   int arg3 ;
86371
86372   arg1 = (std::vector< unsigned int > *)jarg1;
86373   arg2 = (int)jarg2;
86374   arg3 = (int)jarg3;
86375   {
86376     try {
86377       try {
86378         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
86379       }
86380       catch(std::out_of_range &_e) {
86381         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86382         return ;
86383       }
86384       catch(std::invalid_argument &_e) {
86385         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
86386         return ;
86387       }
86388
86389     } catch (std::out_of_range& e) {
86390       {
86391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86392       };
86393     } catch (std::exception& e) {
86394       {
86395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86396       };
86397     } catch (...) {
86398       {
86399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86400       };
86401     }
86402   }
86403 }
86404
86405
86406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
86407   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86408   int arg2 ;
86409   std::vector< unsigned int > *arg3 = 0 ;
86410
86411   arg1 = (std::vector< unsigned int > *)jarg1;
86412   arg2 = (int)jarg2;
86413   arg3 = (std::vector< unsigned int > *)jarg3;
86414   if (!arg3) {
86415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
86416     return ;
86417   }
86418   {
86419     try {
86420       try {
86421         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
86422       }
86423       catch(std::out_of_range &_e) {
86424         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86425         return ;
86426       }
86427
86428     } catch (std::out_of_range& e) {
86429       {
86430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86431       };
86432     } catch (std::exception& e) {
86433       {
86434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86435       };
86436     } catch (...) {
86437       {
86438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86439       };
86440     }
86441   }
86442 }
86443
86444
86445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
86446   unsigned int jresult ;
86447   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86448   unsigned int *arg2 = 0 ;
86449   unsigned int temp2 ;
86450   bool result;
86451
86452   arg1 = (std::vector< unsigned int > *)jarg1;
86453   temp2 = (unsigned int)jarg2;
86454   arg2 = &temp2;
86455   {
86456     try {
86457       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
86458     } catch (std::out_of_range& e) {
86459       {
86460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86461       };
86462     } catch (std::exception& e) {
86463       {
86464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86465       };
86466     } catch (...) {
86467       {
86468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86469       };
86470     }
86471   }
86472   jresult = result;
86473   return jresult;
86474 }
86475
86476
86477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
86478   int jresult ;
86479   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86480   unsigned int *arg2 = 0 ;
86481   unsigned int temp2 ;
86482   int result;
86483
86484   arg1 = (std::vector< unsigned int > *)jarg1;
86485   temp2 = (unsigned int)jarg2;
86486   arg2 = &temp2;
86487   {
86488     try {
86489       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
86490     } catch (std::out_of_range& e) {
86491       {
86492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86493       };
86494     } catch (std::exception& e) {
86495       {
86496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86497       };
86498     } catch (...) {
86499       {
86500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86501       };
86502     }
86503   }
86504   jresult = result;
86505   return jresult;
86506 }
86507
86508
86509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
86510   int jresult ;
86511   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86512   unsigned int *arg2 = 0 ;
86513   unsigned int temp2 ;
86514   int result;
86515
86516   arg1 = (std::vector< unsigned int > *)jarg1;
86517   temp2 = (unsigned int)jarg2;
86518   arg2 = &temp2;
86519   {
86520     try {
86521       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
86522     } catch (std::out_of_range& e) {
86523       {
86524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86525       };
86526     } catch (std::exception& e) {
86527       {
86528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86529       };
86530     } catch (...) {
86531       {
86532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86533       };
86534     }
86535   }
86536   jresult = result;
86537   return jresult;
86538 }
86539
86540
86541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
86542   unsigned int jresult ;
86543   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86544   unsigned int *arg2 = 0 ;
86545   unsigned int temp2 ;
86546   bool result;
86547
86548   arg1 = (std::vector< unsigned int > *)jarg1;
86549   temp2 = (unsigned int)jarg2;
86550   arg2 = &temp2;
86551   {
86552     try {
86553       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
86554     } catch (std::out_of_range& e) {
86555       {
86556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86557       };
86558     } catch (std::exception& e) {
86559       {
86560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86561       };
86562     } catch (...) {
86563       {
86564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86565       };
86566     }
86567   }
86568   jresult = result;
86569   return jresult;
86570 }
86571
86572
86573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
86574   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86575
86576   arg1 = (std::vector< unsigned int > *)jarg1;
86577   {
86578     try {
86579       delete arg1;
86580     } catch (std::out_of_range& e) {
86581       {
86582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86583       };
86584     } catch (std::exception& e) {
86585       {
86586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86587       };
86588     } catch (...) {
86589       {
86590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86591       };
86592     }
86593   }
86594 }
86595
86596
86597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
86598   void * jresult ;
86599   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86600
86601   {
86602     try {
86603       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
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 = (void *)result;
86619   return jresult;
86620 }
86621
86622
86623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
86624   void * jresult ;
86625   unsigned int arg1 ;
86626   Dali::Actor arg2 ;
86627   Dali::Actor *argp2 ;
86628   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86629
86630   arg1 = (unsigned int)jarg1;
86631   argp2 = (Dali::Actor *)jarg2;
86632   if (!argp2) {
86633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86634     return 0;
86635   }
86636   arg2 = *argp2;
86637   {
86638     try {
86639       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
86640     } catch (std::out_of_range& e) {
86641       {
86642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86643       };
86644     } catch (std::exception& e) {
86645       {
86646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86647       };
86648     } catch (...) {
86649       {
86650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86651       };
86652     }
86653   }
86654   jresult = (void *)result;
86655   return jresult;
86656 }
86657
86658
86659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
86660   void * jresult ;
86661   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
86662   std::pair< unsigned int,Dali::Actor > *result = 0 ;
86663
86664   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86665   if (!arg1) {
86666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86667     return 0;
86668   }
86669   {
86670     try {
86671       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
86672     } catch (std::out_of_range& e) {
86673       {
86674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86675       };
86676     } catch (std::exception& e) {
86677       {
86678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86679       };
86680     } catch (...) {
86681       {
86682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86683       };
86684     }
86685   }
86686   jresult = (void *)result;
86687   return jresult;
86688 }
86689
86690
86691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
86692   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86693   unsigned int arg2 ;
86694
86695   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86696   arg2 = (unsigned int)jarg2;
86697   if (arg1) (arg1)->first = arg2;
86698 }
86699
86700
86701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
86702   unsigned int jresult ;
86703   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86704   unsigned int result;
86705
86706   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86707   result = (unsigned int) ((arg1)->first);
86708   jresult = result;
86709   return jresult;
86710 }
86711
86712
86713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
86714   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86715   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
86716
86717   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86718   arg2 = (Dali::Actor *)jarg2;
86719   if (arg1) (arg1)->second = *arg2;
86720 }
86721
86722
86723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
86724   void * jresult ;
86725   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86726   Dali::Actor *result = 0 ;
86727
86728   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86729   result = (Dali::Actor *)& ((arg1)->second);
86730   jresult = (void *)result;
86731   return jresult;
86732 }
86733
86734
86735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
86736   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
86737
86738   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
86739   {
86740     try {
86741       delete arg1;
86742     } catch (std::out_of_range& e) {
86743       {
86744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86745       };
86746     } catch (std::exception& e) {
86747       {
86748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86749       };
86750     } catch (...) {
86751       {
86752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86753       };
86754     }
86755   }
86756 }
86757
86758
86759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
86760   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86761
86762   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86763   {
86764     try {
86765       (arg1)->clear();
86766     } catch (std::out_of_range& e) {
86767       {
86768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86769       };
86770     } catch (std::exception& e) {
86771       {
86772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86773       };
86774     } catch (...) {
86775       {
86776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86777       };
86778     }
86779   }
86780 }
86781
86782
86783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
86784   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86785   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
86786
86787   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86788   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
86789   if (!arg2) {
86790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
86791     return ;
86792   }
86793   {
86794     try {
86795       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
86796     } catch (std::out_of_range& e) {
86797       {
86798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86799       };
86800     } catch (std::exception& e) {
86801       {
86802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86803       };
86804     } catch (...) {
86805       {
86806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86807       };
86808     }
86809   }
86810 }
86811
86812
86813 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
86814   unsigned long jresult ;
86815   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86816   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86817
86818   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86819   {
86820     try {
86821       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
86822     } catch (std::out_of_range& e) {
86823       {
86824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86825       };
86826     } catch (std::exception& e) {
86827       {
86828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86829       };
86830     } catch (...) {
86831       {
86832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86833       };
86834     }
86835   }
86836   jresult = (unsigned long)result;
86837   return jresult;
86838 }
86839
86840
86841 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
86842   unsigned long jresult ;
86843   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86844   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
86845
86846   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86847   {
86848     try {
86849       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
86850     } catch (std::out_of_range& e) {
86851       {
86852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86853       };
86854     } catch (std::exception& e) {
86855       {
86856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86857       };
86858     } catch (...) {
86859       {
86860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86861       };
86862     }
86863   }
86864   jresult = (unsigned long)result;
86865   return jresult;
86866 }
86867
86868
86869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
86870   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86871   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
86872
86873   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86874   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
86875   {
86876     try {
86877       (arg1)->reserve(arg2);
86878     } catch (std::out_of_range& e) {
86879       {
86880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86881       };
86882     } catch (std::exception& e) {
86883       {
86884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86885       };
86886     } catch (...) {
86887       {
86888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86889       };
86890     }
86891   }
86892 }
86893
86894
86895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
86896   void * jresult ;
86897   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86898
86899   {
86900     try {
86901       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
86902     } catch (std::out_of_range& e) {
86903       {
86904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86905       };
86906     } catch (std::exception& e) {
86907       {
86908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86909       };
86910     } catch (...) {
86911       {
86912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86913       };
86914     }
86915   }
86916   jresult = (void *)result;
86917   return jresult;
86918 }
86919
86920
86921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
86922   void * jresult ;
86923   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
86924   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86925
86926   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86927   if (!arg1) {
86928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
86929     return 0;
86930   }
86931   {
86932     try {
86933       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);
86934     } catch (std::out_of_range& e) {
86935       {
86936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86937       };
86938     } catch (std::exception& e) {
86939       {
86940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86941       };
86942     } catch (...) {
86943       {
86944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86945       };
86946     }
86947   }
86948   jresult = (void *)result;
86949   return jresult;
86950 }
86951
86952
86953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
86954   void * jresult ;
86955   int arg1 ;
86956   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
86957
86958   arg1 = (int)jarg1;
86959   {
86960     try {
86961       try {
86962         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);
86963       }
86964       catch(std::out_of_range &_e) {
86965         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
86966         return 0;
86967       }
86968
86969     } catch (std::out_of_range& e) {
86970       {
86971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86972       };
86973     } catch (std::exception& e) {
86974       {
86975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86976       };
86977     } catch (...) {
86978       {
86979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86980       };
86981     }
86982   }
86983   jresult = (void *)result;
86984   return jresult;
86985 }
86986
86987
86988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
86989   void * jresult ;
86990   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
86991   int arg2 ;
86992   std::pair< unsigned int,Dali::Actor > result;
86993
86994   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
86995   arg2 = (int)jarg2;
86996   {
86997     try {
86998       try {
86999         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
87000       }
87001       catch(std::out_of_range &_e) {
87002         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87003         return 0;
87004       }
87005
87006     } catch (std::out_of_range& e) {
87007       {
87008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87009       };
87010     } catch (std::exception& e) {
87011       {
87012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87013       };
87014     } catch (...) {
87015       {
87016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87017       };
87018     }
87019   }
87020   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
87021   return jresult;
87022 }
87023
87024
87025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
87026   void * jresult ;
87027   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87028   int arg2 ;
87029   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87030
87031   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87032   arg2 = (int)jarg2;
87033   {
87034     try {
87035       try {
87036         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
87037       }
87038       catch(std::out_of_range &_e) {
87039         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87040         return 0;
87041       }
87042
87043     } catch (std::out_of_range& e) {
87044       {
87045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87046       };
87047     } catch (std::exception& e) {
87048       {
87049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87050       };
87051     } catch (...) {
87052       {
87053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87054       };
87055     }
87056   }
87057   jresult = (void *)result;
87058   return jresult;
87059 }
87060
87061
87062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87063   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87064   int arg2 ;
87065   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87066
87067   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87068   arg2 = (int)jarg2;
87069   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87070   if (!arg3) {
87071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87072     return ;
87073   }
87074   {
87075     try {
87076       try {
87077         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);
87078       }
87079       catch(std::out_of_range &_e) {
87080         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87081         return ;
87082       }
87083
87084     } catch (std::out_of_range& e) {
87085       {
87086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87087       };
87088     } catch (std::exception& e) {
87089       {
87090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87091       };
87092     } catch (...) {
87093       {
87094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87095       };
87096     }
87097   }
87098 }
87099
87100
87101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
87102   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87103   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
87104
87105   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87106   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
87107   if (!arg2) {
87108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87109     return ;
87110   }
87111   {
87112     try {
87113       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);
87114     } catch (std::out_of_range& e) {
87115       {
87116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87117       };
87118     } catch (std::exception& e) {
87119       {
87120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87121       };
87122     } catch (...) {
87123       {
87124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87125       };
87126     }
87127   }
87128 }
87129
87130
87131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87132   void * jresult ;
87133   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87134   int arg2 ;
87135   int arg3 ;
87136   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87137
87138   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87139   arg2 = (int)jarg2;
87140   arg3 = (int)jarg3;
87141   {
87142     try {
87143       try {
87144         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);
87145       }
87146       catch(std::out_of_range &_e) {
87147         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87148         return 0;
87149       }
87150       catch(std::invalid_argument &_e) {
87151         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87152         return 0;
87153       }
87154
87155     } catch (std::out_of_range& e) {
87156       {
87157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87158       };
87159     } catch (std::exception& e) {
87160       {
87161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87162       };
87163     } catch (...) {
87164       {
87165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87166       };
87167     }
87168   }
87169   jresult = (void *)result;
87170   return jresult;
87171 }
87172
87173
87174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87175   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87176   int arg2 ;
87177   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
87178
87179   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87180   arg2 = (int)jarg2;
87181   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
87182   if (!arg3) {
87183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87184     return ;
87185   }
87186   {
87187     try {
87188       try {
87189         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);
87190       }
87191       catch(std::out_of_range &_e) {
87192         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87193         return ;
87194       }
87195
87196     } catch (std::out_of_range& e) {
87197       {
87198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87199       };
87200     } catch (std::exception& e) {
87201       {
87202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87203       };
87204     } catch (...) {
87205       {
87206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87207       };
87208     }
87209   }
87210 }
87211
87212
87213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87214   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87215   int arg2 ;
87216   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87217
87218   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87219   arg2 = (int)jarg2;
87220   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87221   if (!arg3) {
87222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87223     return ;
87224   }
87225   {
87226     try {
87227       try {
87228         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);
87229       }
87230       catch(std::out_of_range &_e) {
87231         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87232         return ;
87233       }
87234
87235     } catch (std::out_of_range& e) {
87236       {
87237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87238       };
87239     } catch (std::exception& e) {
87240       {
87241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87242       };
87243     } catch (...) {
87244       {
87245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87246       };
87247     }
87248   }
87249 }
87250
87251
87252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
87253   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87254   int arg2 ;
87255
87256   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87257   arg2 = (int)jarg2;
87258   {
87259     try {
87260       try {
87261         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
87262       }
87263       catch(std::out_of_range &_e) {
87264         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87265         return ;
87266       }
87267
87268     } catch (std::out_of_range& e) {
87269       {
87270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87271       };
87272     } catch (std::exception& e) {
87273       {
87274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87275       };
87276     } catch (...) {
87277       {
87278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87279       };
87280     }
87281   }
87282 }
87283
87284
87285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87286   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87287   int arg2 ;
87288   int arg3 ;
87289
87290   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87291   arg2 = (int)jarg2;
87292   arg3 = (int)jarg3;
87293   {
87294     try {
87295       try {
87296         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
87297       }
87298       catch(std::out_of_range &_e) {
87299         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87300         return ;
87301       }
87302       catch(std::invalid_argument &_e) {
87303         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87304         return ;
87305       }
87306
87307     } catch (std::out_of_range& e) {
87308       {
87309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87310       };
87311     } catch (std::exception& e) {
87312       {
87313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87314       };
87315     } catch (...) {
87316       {
87317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87318       };
87319     }
87320   }
87321 }
87322
87323
87324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
87325   void * jresult ;
87326   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87327   int arg2 ;
87328   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
87329
87330   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87331   if (!arg1) {
87332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87333     return 0;
87334   }
87335   arg2 = (int)jarg2;
87336   {
87337     try {
87338       try {
87339         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);
87340       }
87341       catch(std::out_of_range &_e) {
87342         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87343         return 0;
87344       }
87345
87346     } catch (std::out_of_range& e) {
87347       {
87348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87349       };
87350     } catch (std::exception& e) {
87351       {
87352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87353       };
87354     } catch (...) {
87355       {
87356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87357       };
87358     }
87359   }
87360   jresult = (void *)result;
87361   return jresult;
87362 }
87363
87364
87365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
87366   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87367
87368   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87369   {
87370     try {
87371       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
87372     } catch (std::out_of_range& e) {
87373       {
87374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87375       };
87376     } catch (std::exception& e) {
87377       {
87378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87379       };
87380     } catch (...) {
87381       {
87382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87383       };
87384     }
87385   }
87386 }
87387
87388
87389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87390   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87391   int arg2 ;
87392   int arg3 ;
87393
87394   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87395   arg2 = (int)jarg2;
87396   arg3 = (int)jarg3;
87397   {
87398     try {
87399       try {
87400         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87401       }
87402       catch(std::out_of_range &_e) {
87403         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87404         return ;
87405       }
87406       catch(std::invalid_argument &_e) {
87407         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87408         return ;
87409       }
87410
87411     } catch (std::out_of_range& e) {
87412       {
87413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87414       };
87415     } catch (std::exception& e) {
87416       {
87417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87418       };
87419     } catch (...) {
87420       {
87421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87422       };
87423     }
87424   }
87425 }
87426
87427
87428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87429   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87430   int arg2 ;
87431   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
87432
87433   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87434   arg2 = (int)jarg2;
87435   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
87436   if (!arg3) {
87437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
87438     return ;
87439   }
87440   {
87441     try {
87442       try {
87443         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);
87444       }
87445       catch(std::out_of_range &_e) {
87446         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87447         return ;
87448       }
87449
87450     } catch (std::out_of_range& e) {
87451       {
87452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87453       };
87454     } catch (std::exception& e) {
87455       {
87456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87457       };
87458     } catch (...) {
87459       {
87460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87461       };
87462     }
87463   }
87464 }
87465
87466
87467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
87468   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
87469
87470   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
87471   {
87472     try {
87473       delete arg1;
87474     } catch (std::out_of_range& e) {
87475       {
87476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87477       };
87478     } catch (std::exception& e) {
87479       {
87480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87481       };
87482     } catch (...) {
87483       {
87484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87485       };
87486     }
87487   }
87488 }
87489
87490
87491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
87492   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87493
87494   arg1 = (std::vector< Dali::Actor > *)jarg1;
87495   {
87496     try {
87497       (arg1)->clear();
87498     } catch (std::out_of_range& e) {
87499       {
87500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87501       };
87502     } catch (std::exception& e) {
87503       {
87504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87505       };
87506     } catch (...) {
87507       {
87508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87509       };
87510     }
87511   }
87512 }
87513
87514
87515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
87516   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87517   Dali::Actor *arg2 = 0 ;
87518
87519   arg1 = (std::vector< Dali::Actor > *)jarg1;
87520   arg2 = (Dali::Actor *)jarg2;
87521   if (!arg2) {
87522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87523     return ;
87524   }
87525   {
87526     try {
87527       (arg1)->push_back((Dali::Actor const &)*arg2);
87528     } catch (std::out_of_range& e) {
87529       {
87530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87531       };
87532     } catch (std::exception& e) {
87533       {
87534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87535       };
87536     } catch (...) {
87537       {
87538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87539       };
87540     }
87541   }
87542 }
87543
87544
87545 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
87546   unsigned long jresult ;
87547   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87548   std::vector< Dali::Actor >::size_type result;
87549
87550   arg1 = (std::vector< Dali::Actor > *)jarg1;
87551   {
87552     try {
87553       result = ((std::vector< Dali::Actor > const *)arg1)->size();
87554     } catch (std::out_of_range& e) {
87555       {
87556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87557       };
87558     } catch (std::exception& e) {
87559       {
87560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87561       };
87562     } catch (...) {
87563       {
87564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87565       };
87566     }
87567   }
87568   jresult = (unsigned long)result;
87569   return jresult;
87570 }
87571
87572
87573 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
87574   unsigned long jresult ;
87575   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87576   std::vector< Dali::Actor >::size_type result;
87577
87578   arg1 = (std::vector< Dali::Actor > *)jarg1;
87579   {
87580     try {
87581       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
87582     } catch (std::out_of_range& e) {
87583       {
87584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87585       };
87586     } catch (std::exception& e) {
87587       {
87588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87589       };
87590     } catch (...) {
87591       {
87592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87593       };
87594     }
87595   }
87596   jresult = (unsigned long)result;
87597   return jresult;
87598 }
87599
87600
87601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
87602   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87603   std::vector< Dali::Actor >::size_type arg2 ;
87604
87605   arg1 = (std::vector< Dali::Actor > *)jarg1;
87606   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
87607   {
87608     try {
87609       (arg1)->reserve(arg2);
87610     } catch (std::out_of_range& e) {
87611       {
87612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87613       };
87614     } catch (std::exception& e) {
87615       {
87616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87617       };
87618     } catch (...) {
87619       {
87620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87621       };
87622     }
87623   }
87624 }
87625
87626
87627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
87628   void * jresult ;
87629   std::vector< Dali::Actor > *result = 0 ;
87630
87631   {
87632     try {
87633       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
87634     } catch (std::out_of_range& e) {
87635       {
87636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87637       };
87638     } catch (std::exception& e) {
87639       {
87640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87641       };
87642     } catch (...) {
87643       {
87644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87645       };
87646     }
87647   }
87648   jresult = (void *)result;
87649   return jresult;
87650 }
87651
87652
87653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
87654   void * jresult ;
87655   std::vector< Dali::Actor > *arg1 = 0 ;
87656   std::vector< Dali::Actor > *result = 0 ;
87657
87658   arg1 = (std::vector< Dali::Actor > *)jarg1;
87659   if (!arg1) {
87660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87661     return 0;
87662   }
87663   {
87664     try {
87665       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
87666     } catch (std::out_of_range& e) {
87667       {
87668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87669       };
87670     } catch (std::exception& e) {
87671       {
87672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87673       };
87674     } catch (...) {
87675       {
87676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87677       };
87678     }
87679   }
87680   jresult = (void *)result;
87681   return jresult;
87682 }
87683
87684
87685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
87686   void * jresult ;
87687   int arg1 ;
87688   std::vector< Dali::Actor > *result = 0 ;
87689
87690   arg1 = (int)jarg1;
87691   {
87692     try {
87693       try {
87694         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
87695       }
87696       catch(std::out_of_range &_e) {
87697         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87698         return 0;
87699       }
87700
87701     } catch (std::out_of_range& e) {
87702       {
87703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87704       };
87705     } catch (std::exception& e) {
87706       {
87707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87708       };
87709     } catch (...) {
87710       {
87711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87712       };
87713     }
87714   }
87715   jresult = (void *)result;
87716   return jresult;
87717 }
87718
87719
87720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
87721   void * jresult ;
87722   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87723   int arg2 ;
87724   Dali::Actor result;
87725
87726   arg1 = (std::vector< Dali::Actor > *)jarg1;
87727   arg2 = (int)jarg2;
87728   {
87729     try {
87730       try {
87731         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
87732       }
87733       catch(std::out_of_range &_e) {
87734         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87735         return 0;
87736       }
87737
87738     } catch (std::out_of_range& e) {
87739       {
87740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87741       };
87742     } catch (std::exception& e) {
87743       {
87744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87745       };
87746     } catch (...) {
87747       {
87748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87749       };
87750     }
87751   }
87752   jresult = new Dali::Actor((const Dali::Actor &)result);
87753   return jresult;
87754 }
87755
87756
87757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
87758   void * jresult ;
87759   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87760   int arg2 ;
87761   Dali::Actor *result = 0 ;
87762
87763   arg1 = (std::vector< Dali::Actor > *)jarg1;
87764   arg2 = (int)jarg2;
87765   {
87766     try {
87767       try {
87768         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
87769       }
87770       catch(std::out_of_range &_e) {
87771         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87772         return 0;
87773       }
87774
87775     } catch (std::out_of_range& e) {
87776       {
87777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87778       };
87779     } catch (std::exception& e) {
87780       {
87781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87782       };
87783     } catch (...) {
87784       {
87785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87786       };
87787     }
87788   }
87789   jresult = (void *)result;
87790   return jresult;
87791 }
87792
87793
87794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
87795   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87796   int arg2 ;
87797   Dali::Actor *arg3 = 0 ;
87798
87799   arg1 = (std::vector< Dali::Actor > *)jarg1;
87800   arg2 = (int)jarg2;
87801   arg3 = (Dali::Actor *)jarg3;
87802   if (!arg3) {
87803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87804     return ;
87805   }
87806   {
87807     try {
87808       try {
87809         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
87810       }
87811       catch(std::out_of_range &_e) {
87812         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87813         return ;
87814       }
87815
87816     } catch (std::out_of_range& e) {
87817       {
87818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87819       };
87820     } catch (std::exception& e) {
87821       {
87822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87823       };
87824     } catch (...) {
87825       {
87826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87827       };
87828     }
87829   }
87830 }
87831
87832
87833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
87834   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87835   std::vector< Dali::Actor > *arg2 = 0 ;
87836
87837   arg1 = (std::vector< Dali::Actor > *)jarg1;
87838   arg2 = (std::vector< Dali::Actor > *)jarg2;
87839   if (!arg2) {
87840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87841     return ;
87842   }
87843   {
87844     try {
87845       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
87846     } catch (std::out_of_range& e) {
87847       {
87848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87849       };
87850     } catch (std::exception& e) {
87851       {
87852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87853       };
87854     } catch (...) {
87855       {
87856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87857       };
87858     }
87859   }
87860 }
87861
87862
87863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87864   void * jresult ;
87865   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87866   int arg2 ;
87867   int arg3 ;
87868   std::vector< Dali::Actor > *result = 0 ;
87869
87870   arg1 = (std::vector< Dali::Actor > *)jarg1;
87871   arg2 = (int)jarg2;
87872   arg3 = (int)jarg3;
87873   {
87874     try {
87875       try {
87876         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
87877       }
87878       catch(std::out_of_range &_e) {
87879         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87880         return 0;
87881       }
87882       catch(std::invalid_argument &_e) {
87883         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87884         return 0;
87885       }
87886
87887     } catch (std::out_of_range& e) {
87888       {
87889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87890       };
87891     } catch (std::exception& e) {
87892       {
87893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87894       };
87895     } catch (...) {
87896       {
87897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87898       };
87899     }
87900   }
87901   jresult = (void *)result;
87902   return jresult;
87903 }
87904
87905
87906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
87907   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87908   int arg2 ;
87909   Dali::Actor *arg3 = 0 ;
87910
87911   arg1 = (std::vector< Dali::Actor > *)jarg1;
87912   arg2 = (int)jarg2;
87913   arg3 = (Dali::Actor *)jarg3;
87914   if (!arg3) {
87915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
87916     return ;
87917   }
87918   {
87919     try {
87920       try {
87921         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
87922       }
87923       catch(std::out_of_range &_e) {
87924         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87925         return ;
87926       }
87927
87928     } catch (std::out_of_range& e) {
87929       {
87930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87931       };
87932     } catch (std::exception& e) {
87933       {
87934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87935       };
87936     } catch (...) {
87937       {
87938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87939       };
87940     }
87941   }
87942 }
87943
87944
87945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87946   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87947   int arg2 ;
87948   std::vector< Dali::Actor > *arg3 = 0 ;
87949
87950   arg1 = (std::vector< Dali::Actor > *)jarg1;
87951   arg2 = (int)jarg2;
87952   arg3 = (std::vector< Dali::Actor > *)jarg3;
87953   if (!arg3) {
87954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
87955     return ;
87956   }
87957   {
87958     try {
87959       try {
87960         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
87961       }
87962       catch(std::out_of_range &_e) {
87963         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87964         return ;
87965       }
87966
87967     } catch (std::out_of_range& e) {
87968       {
87969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87970       };
87971     } catch (std::exception& e) {
87972       {
87973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87974       };
87975     } catch (...) {
87976       {
87977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87978       };
87979     }
87980   }
87981 }
87982
87983
87984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
87985   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
87986   int arg2 ;
87987
87988   arg1 = (std::vector< Dali::Actor > *)jarg1;
87989   arg2 = (int)jarg2;
87990   {
87991     try {
87992       try {
87993         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
87994       }
87995       catch(std::out_of_range &_e) {
87996         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87997         return ;
87998       }
87999
88000     } catch (std::out_of_range& e) {
88001       {
88002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88003       };
88004     } catch (std::exception& e) {
88005       {
88006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88007       };
88008     } catch (...) {
88009       {
88010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88011       };
88012     }
88013   }
88014 }
88015
88016
88017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88018   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88019   int arg2 ;
88020   int arg3 ;
88021
88022   arg1 = (std::vector< Dali::Actor > *)jarg1;
88023   arg2 = (int)jarg2;
88024   arg3 = (int)jarg3;
88025   {
88026     try {
88027       try {
88028         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
88029       }
88030       catch(std::out_of_range &_e) {
88031         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88032         return ;
88033       }
88034       catch(std::invalid_argument &_e) {
88035         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88036         return ;
88037       }
88038
88039     } catch (std::out_of_range& e) {
88040       {
88041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88042       };
88043     } catch (std::exception& e) {
88044       {
88045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88046       };
88047     } catch (...) {
88048       {
88049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88050       };
88051     }
88052   }
88053 }
88054
88055
88056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
88057   void * jresult ;
88058   Dali::Actor *arg1 = 0 ;
88059   int arg2 ;
88060   std::vector< Dali::Actor > *result = 0 ;
88061
88062   arg1 = (Dali::Actor *)jarg1;
88063   if (!arg1) {
88064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88065     return 0;
88066   }
88067   arg2 = (int)jarg2;
88068   {
88069     try {
88070       try {
88071         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
88072       }
88073       catch(std::out_of_range &_e) {
88074         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88075         return 0;
88076       }
88077
88078     } catch (std::out_of_range& e) {
88079       {
88080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88081       };
88082     } catch (std::exception& e) {
88083       {
88084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88085       };
88086     } catch (...) {
88087       {
88088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88089       };
88090     }
88091   }
88092   jresult = (void *)result;
88093   return jresult;
88094 }
88095
88096
88097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
88098   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88099
88100   arg1 = (std::vector< Dali::Actor > *)jarg1;
88101   {
88102     try {
88103       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
88104     } catch (std::out_of_range& e) {
88105       {
88106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88107       };
88108     } catch (std::exception& e) {
88109       {
88110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88111       };
88112     } catch (...) {
88113       {
88114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88115       };
88116     }
88117   }
88118 }
88119
88120
88121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88122   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88123   int arg2 ;
88124   int arg3 ;
88125
88126   arg1 = (std::vector< Dali::Actor > *)jarg1;
88127   arg2 = (int)jarg2;
88128   arg3 = (int)jarg3;
88129   {
88130     try {
88131       try {
88132         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88133       }
88134       catch(std::out_of_range &_e) {
88135         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88136         return ;
88137       }
88138       catch(std::invalid_argument &_e) {
88139         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88140         return ;
88141       }
88142
88143     } catch (std::out_of_range& e) {
88144       {
88145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88146       };
88147     } catch (std::exception& e) {
88148       {
88149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88150       };
88151     } catch (...) {
88152       {
88153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88154       };
88155     }
88156   }
88157 }
88158
88159
88160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88161   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88162   int arg2 ;
88163   std::vector< Dali::Actor > *arg3 = 0 ;
88164
88165   arg1 = (std::vector< Dali::Actor > *)jarg1;
88166   arg2 = (int)jarg2;
88167   arg3 = (std::vector< Dali::Actor > *)jarg3;
88168   if (!arg3) {
88169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
88170     return ;
88171   }
88172   {
88173     try {
88174       try {
88175         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
88176       }
88177       catch(std::out_of_range &_e) {
88178         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88179         return ;
88180       }
88181
88182     } catch (std::out_of_range& e) {
88183       {
88184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88185       };
88186     } catch (std::exception& e) {
88187       {
88188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88189       };
88190     } catch (...) {
88191       {
88192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88193       };
88194     }
88195   }
88196 }
88197
88198
88199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
88200   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88201
88202   arg1 = (std::vector< Dali::Actor > *)jarg1;
88203   {
88204     try {
88205       delete arg1;
88206     } catch (std::out_of_range& e) {
88207       {
88208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88209       };
88210     } catch (std::exception& e) {
88211       {
88212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88213       };
88214     } catch (...) {
88215       {
88216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88217       };
88218     }
88219   }
88220 }
88221
88222
88223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
88224   unsigned int jresult ;
88225   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88226   bool result;
88227
88228   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88229   {
88230     try {
88231       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88232     } catch (std::out_of_range& e) {
88233       {
88234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88235       };
88236     } catch (std::exception& e) {
88237       {
88238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88239       };
88240     } catch (...) {
88241       {
88242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88243       };
88244     }
88245   }
88246   jresult = result;
88247   return jresult;
88248 }
88249
88250
88251 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
88252   unsigned long jresult ;
88253   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88254   std::size_t result;
88255
88256   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88257   {
88258     try {
88259       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
88260     } catch (std::out_of_range& e) {
88261       {
88262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88263       };
88264     } catch (std::exception& e) {
88265       {
88266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88267       };
88268     } catch (...) {
88269       {
88270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88271       };
88272     }
88273   }
88274   jresult = (unsigned long)result;
88275   return jresult;
88276 }
88277
88278
88279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
88280   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88281   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88282
88283   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88284   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88285   {
88286     try {
88287       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
88288     } catch (std::out_of_range& e) {
88289       {
88290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88291       };
88292     } catch (std::exception& e) {
88293       {
88294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88295       };
88296     } catch (...) {
88297       {
88298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88299       };
88300     }
88301   }
88302 }
88303
88304
88305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
88306   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88307   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
88308
88309   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88310   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
88311   {
88312     try {
88313       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
88314     } catch (std::out_of_range& e) {
88315       {
88316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88317       };
88318     } catch (std::exception& e) {
88319       {
88320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88321       };
88322     } catch (...) {
88323       {
88324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88325       };
88326     }
88327   }
88328 }
88329
88330
88331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
88332   unsigned int jresult ;
88333   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88334   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
88335   bool result;
88336
88337   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88338   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
88339   if (!arg2) {
88340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
88341     return 0;
88342   }
88343   {
88344     try {
88345       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
88346     } catch (std::out_of_range& e) {
88347       {
88348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88349       };
88350     } catch (std::exception& e) {
88351       {
88352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88353       };
88354     } catch (...) {
88355       {
88356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88357       };
88358     }
88359   }
88360   jresult = result;
88361   return jresult;
88362 }
88363
88364
88365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
88366   void * jresult ;
88367   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
88368
88369   {
88370     try {
88371       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
88372     } catch (std::out_of_range& e) {
88373       {
88374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88375       };
88376     } catch (std::exception& e) {
88377       {
88378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88379       };
88380     } catch (...) {
88381       {
88382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88383       };
88384     }
88385   }
88386   jresult = (void *)result;
88387   return jresult;
88388 }
88389
88390
88391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
88392   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
88393
88394   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
88395   {
88396     try {
88397       delete arg1;
88398     } catch (std::out_of_range& e) {
88399       {
88400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88401       };
88402     } catch (std::exception& e) {
88403       {
88404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88405       };
88406     } catch (...) {
88407       {
88408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88409       };
88410     }
88411   }
88412 }
88413
88414
88415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
88416   unsigned int jresult ;
88417   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88418   bool result;
88419
88420   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88421   {
88422     try {
88423       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);
88424     } catch (std::out_of_range& e) {
88425       {
88426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88427       };
88428     } catch (std::exception& e) {
88429       {
88430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88431       };
88432     } catch (...) {
88433       {
88434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88435       };
88436     }
88437   }
88438   jresult = result;
88439   return jresult;
88440 }
88441
88442
88443 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
88444   unsigned long jresult ;
88445   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88446   std::size_t result;
88447
88448   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88449   {
88450     try {
88451       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);
88452     } catch (std::out_of_range& e) {
88453       {
88454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88455       };
88456     } catch (std::exception& e) {
88457       {
88458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88459       };
88460     } catch (...) {
88461       {
88462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88463       };
88464     }
88465   }
88466   jresult = (unsigned long)result;
88467   return jresult;
88468 }
88469
88470
88471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
88472   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88473   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88474
88475   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88476   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88477   {
88478     try {
88479       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
88480     } catch (std::out_of_range& e) {
88481       {
88482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88483       };
88484     } catch (std::exception& e) {
88485       {
88486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88487       };
88488     } catch (...) {
88489       {
88490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88491       };
88492     }
88493   }
88494 }
88495
88496
88497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
88498   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88499   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
88500
88501   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88502   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
88503   {
88504     try {
88505       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
88506     } catch (std::out_of_range& e) {
88507       {
88508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88509       };
88510     } catch (std::exception& e) {
88511       {
88512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88513       };
88514     } catch (...) {
88515       {
88516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88517       };
88518     }
88519   }
88520 }
88521
88522
88523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
88524   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88525   Dali::Actor arg2 ;
88526   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
88527   Dali::Actor *argp2 ;
88528
88529   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88530   argp2 = (Dali::Actor *)jarg2;
88531   if (!argp2) {
88532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88533     return ;
88534   }
88535   arg2 = *argp2;
88536   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
88537   {
88538     try {
88539       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
88540     } catch (std::out_of_range& e) {
88541       {
88542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88543       };
88544     } catch (std::exception& e) {
88545       {
88546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88547       };
88548     } catch (...) {
88549       {
88550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88551       };
88552     }
88553   }
88554 }
88555
88556
88557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
88558   void * jresult ;
88559   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
88560
88561   {
88562     try {
88563       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
88564     } catch (std::out_of_range& e) {
88565       {
88566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88567       };
88568     } catch (std::exception& e) {
88569       {
88570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88571       };
88572     } catch (...) {
88573       {
88574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88575       };
88576     }
88577   }
88578   jresult = (void *)result;
88579   return jresult;
88580 }
88581
88582
88583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
88584   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
88585
88586   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
88587   {
88588     try {
88589       delete arg1;
88590     } catch (std::out_of_range& e) {
88591       {
88592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88593       };
88594     } catch (std::exception& e) {
88595       {
88596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88597       };
88598     } catch (...) {
88599       {
88600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88601       };
88602     }
88603   }
88604 }
88605
88606
88607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
88608   unsigned int jresult ;
88609   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88610   bool result;
88611
88612   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88613   {
88614     try {
88615       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88616     } catch (std::out_of_range& e) {
88617       {
88618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88619       };
88620     } catch (std::exception& e) {
88621       {
88622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88623       };
88624     } catch (...) {
88625       {
88626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88627       };
88628     }
88629   }
88630   jresult = result;
88631   return jresult;
88632 }
88633
88634
88635 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
88636   unsigned long jresult ;
88637   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88638   std::size_t result;
88639
88640   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88641   {
88642     try {
88643       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
88644     } catch (std::out_of_range& e) {
88645       {
88646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88647       };
88648     } catch (std::exception& e) {
88649       {
88650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88651       };
88652     } catch (...) {
88653       {
88654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88655       };
88656     }
88657   }
88658   jresult = (unsigned long)result;
88659   return jresult;
88660 }
88661
88662
88663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
88664   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88665   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88666
88667   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88668   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88669   {
88670     try {
88671       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
88672     } catch (std::out_of_range& e) {
88673       {
88674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88675       };
88676     } catch (std::exception& e) {
88677       {
88678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88679       };
88680     } catch (...) {
88681       {
88682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88683       };
88684     }
88685   }
88686 }
88687
88688
88689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88690   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88691   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
88692
88693   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88694   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
88695   {
88696     try {
88697       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
88698     } catch (std::out_of_range& e) {
88699       {
88700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88701       };
88702     } catch (std::exception& e) {
88703       {
88704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88705       };
88706     } catch (...) {
88707       {
88708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88709       };
88710     }
88711   }
88712 }
88713
88714
88715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
88716   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88717   Dali::Actor arg2 ;
88718   Dali::Actor arg3 ;
88719   Dali::Actor *argp2 ;
88720   Dali::Actor *argp3 ;
88721
88722   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88723   argp2 = (Dali::Actor *)jarg2;
88724   if (!argp2) {
88725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88726     return ;
88727   }
88728   arg2 = *argp2;
88729   argp3 = (Dali::Actor *)jarg3;
88730   if (!argp3) {
88731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88732     return ;
88733   }
88734   arg3 = *argp3;
88735   {
88736     try {
88737       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
88738     } catch (std::out_of_range& e) {
88739       {
88740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88741       };
88742     } catch (std::exception& e) {
88743       {
88744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88745       };
88746     } catch (...) {
88747       {
88748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88749       };
88750     }
88751   }
88752 }
88753
88754
88755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
88756   void * jresult ;
88757   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
88758
88759   {
88760     try {
88761       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
88762     } catch (std::out_of_range& e) {
88763       {
88764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88765       };
88766     } catch (std::exception& e) {
88767       {
88768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88769       };
88770     } catch (...) {
88771       {
88772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88773       };
88774     }
88775   }
88776   jresult = (void *)result;
88777   return jresult;
88778 }
88779
88780
88781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
88782   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
88783
88784   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
88785   {
88786     try {
88787       delete arg1;
88788     } catch (std::out_of_range& e) {
88789       {
88790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88791       };
88792     } catch (std::exception& e) {
88793       {
88794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88795       };
88796     } catch (...) {
88797       {
88798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88799       };
88800     }
88801   }
88802 }
88803
88804
88805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
88806   unsigned int jresult ;
88807   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88808   bool result;
88809
88810   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88811   {
88812     try {
88813       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88814     } catch (std::out_of_range& e) {
88815       {
88816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88817       };
88818     } catch (std::exception& e) {
88819       {
88820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88821       };
88822     } catch (...) {
88823       {
88824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88825       };
88826     }
88827   }
88828   jresult = result;
88829   return jresult;
88830 }
88831
88832
88833 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
88834   unsigned long jresult ;
88835   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88836   std::size_t result;
88837
88838   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88839   {
88840     try {
88841       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
88842     } catch (std::out_of_range& e) {
88843       {
88844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88845       };
88846     } catch (std::exception& e) {
88847       {
88848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88849       };
88850     } catch (...) {
88851       {
88852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88853       };
88854     }
88855   }
88856   jresult = (unsigned long)result;
88857   return jresult;
88858 }
88859
88860
88861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
88862   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88863   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88864
88865   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88866   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88867   {
88868     try {
88869       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
88870     } catch (std::out_of_range& e) {
88871       {
88872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88873       };
88874     } catch (std::exception& e) {
88875       {
88876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88877       };
88878     } catch (...) {
88879       {
88880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88881       };
88882     }
88883   }
88884 }
88885
88886
88887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
88888   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88889   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
88890
88891   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88892   arg2 = (void (*)(Dali::Actor,bool))jarg2;
88893   {
88894     try {
88895       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
88896     } catch (std::out_of_range& e) {
88897       {
88898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88899       };
88900     } catch (std::exception& e) {
88901       {
88902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88903       };
88904     } catch (...) {
88905       {
88906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88907       };
88908     }
88909   }
88910 }
88911
88912
88913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
88914   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88915   Dali::Actor arg2 ;
88916   bool arg3 ;
88917   Dali::Actor *argp2 ;
88918
88919   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88920   argp2 = (Dali::Actor *)jarg2;
88921   if (!argp2) {
88922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88923     return ;
88924   }
88925   arg2 = *argp2;
88926   arg3 = jarg3 ? true : false;
88927   {
88928     try {
88929       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
88930     } catch (std::out_of_range& e) {
88931       {
88932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88933       };
88934     } catch (std::exception& e) {
88935       {
88936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88937       };
88938     } catch (...) {
88939       {
88940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88941       };
88942     }
88943   }
88944 }
88945
88946
88947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
88948   void * jresult ;
88949   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
88950
88951   {
88952     try {
88953       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
88954     } catch (std::out_of_range& e) {
88955       {
88956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88957       };
88958     } catch (std::exception& e) {
88959       {
88960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88961       };
88962     } catch (...) {
88963       {
88964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88965       };
88966     }
88967   }
88968   jresult = (void *)result;
88969   return jresult;
88970 }
88971
88972
88973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
88974   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
88975
88976   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
88977   {
88978     try {
88979       delete arg1;
88980     } catch (std::out_of_range& e) {
88981       {
88982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88983       };
88984     } catch (std::exception& e) {
88985       {
88986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88987       };
88988     } catch (...) {
88989       {
88990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88991       };
88992     }
88993   }
88994 }
88995
88996
88997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
88998   unsigned int jresult ;
88999   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89000   bool result;
89001
89002   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89003   {
89004     try {
89005       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);
89006     } catch (std::out_of_range& e) {
89007       {
89008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89009       };
89010     } catch (std::exception& e) {
89011       {
89012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89013       };
89014     } catch (...) {
89015       {
89016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89017       };
89018     }
89019   }
89020   jresult = result;
89021   return jresult;
89022 }
89023
89024
89025 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
89026   unsigned long jresult ;
89027   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89028   std::size_t result;
89029
89030   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89031   {
89032     try {
89033       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);
89034     } catch (std::out_of_range& e) {
89035       {
89036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89037       };
89038     } catch (std::exception& e) {
89039       {
89040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89041       };
89042     } catch (...) {
89043       {
89044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89045       };
89046     }
89047   }
89048   jresult = (unsigned long)result;
89049   return jresult;
89050 }
89051
89052
89053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
89054   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89055   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89056
89057   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89058   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89059   {
89060     try {
89061       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
89062     } catch (std::out_of_range& e) {
89063       {
89064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89065       };
89066     } catch (std::exception& e) {
89067       {
89068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89069       };
89070     } catch (...) {
89071       {
89072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89073       };
89074     }
89075   }
89076 }
89077
89078
89079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
89080   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89081   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
89082
89083   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89084   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
89085   {
89086     try {
89087       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
89088     } catch (std::out_of_range& e) {
89089       {
89090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89091       };
89092     } catch (std::exception& e) {
89093       {
89094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89095       };
89096     } catch (...) {
89097       {
89098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89099       };
89100     }
89101   }
89102 }
89103
89104
89105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
89106   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89107   Dali::Toolkit::StyleManager arg2 ;
89108   Dali::StyleChange::Type arg3 ;
89109   Dali::Toolkit::StyleManager *argp2 ;
89110
89111   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89112   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
89113   if (!argp2) {
89114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
89115     return ;
89116   }
89117   arg2 = *argp2;
89118   arg3 = (Dali::StyleChange::Type)jarg3;
89119   {
89120     try {
89121       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
89122     } catch (std::out_of_range& e) {
89123       {
89124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89125       };
89126     } catch (std::exception& e) {
89127       {
89128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89129       };
89130     } catch (...) {
89131       {
89132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89133       };
89134     }
89135   }
89136 }
89137
89138
89139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
89140   void * jresult ;
89141   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
89142
89143   {
89144     try {
89145       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
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 = (void *)result;
89161   return jresult;
89162 }
89163
89164
89165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
89166   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
89167
89168   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
89169   {
89170     try {
89171       delete arg1;
89172     } catch (std::out_of_range& e) {
89173       {
89174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89175       };
89176     } catch (std::exception& e) {
89177       {
89178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89179       };
89180     } catch (...) {
89181       {
89182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89183       };
89184     }
89185   }
89186 }
89187
89188
89189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
89190   unsigned int jresult ;
89191   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89192   bool result;
89193
89194   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89195   {
89196     try {
89197       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89198     } catch (std::out_of_range& e) {
89199       {
89200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89201       };
89202     } catch (std::exception& e) {
89203       {
89204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89205       };
89206     } catch (...) {
89207       {
89208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89209       };
89210     }
89211   }
89212   jresult = result;
89213   return jresult;
89214 }
89215
89216
89217 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
89218   unsigned long jresult ;
89219   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89220   std::size_t result;
89221
89222   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89223   {
89224     try {
89225       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
89226     } catch (std::out_of_range& e) {
89227       {
89228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89229       };
89230     } catch (std::exception& e) {
89231       {
89232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89233       };
89234     } catch (...) {
89235       {
89236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89237       };
89238     }
89239   }
89240   jresult = (unsigned long)result;
89241   return jresult;
89242 }
89243
89244
89245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
89246   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89247   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89248
89249   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89250   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89251   {
89252     try {
89253       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
89254     } catch (std::out_of_range& e) {
89255       {
89256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89257       };
89258     } catch (std::exception& e) {
89259       {
89260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89261       };
89262     } catch (...) {
89263       {
89264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89265       };
89266     }
89267   }
89268 }
89269
89270
89271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
89272   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89273   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
89274
89275   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89276   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
89277   {
89278     try {
89279       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
89280     } catch (std::out_of_range& e) {
89281       {
89282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89283       };
89284     } catch (std::exception& e) {
89285       {
89286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89287       };
89288     } catch (...) {
89289       {
89290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89291       };
89292     }
89293   }
89294 }
89295
89296
89297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
89298   unsigned int jresult ;
89299   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89300   Dali::Toolkit::Button arg2 ;
89301   Dali::Toolkit::Button *argp2 ;
89302   bool result;
89303
89304   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89305   argp2 = (Dali::Toolkit::Button *)jarg2;
89306   if (!argp2) {
89307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
89308     return 0;
89309   }
89310   arg2 = *argp2;
89311   {
89312     try {
89313       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
89314     } catch (std::out_of_range& e) {
89315       {
89316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89317       };
89318     } catch (std::exception& e) {
89319       {
89320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89321       };
89322     } catch (...) {
89323       {
89324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89325       };
89326     }
89327   }
89328   jresult = result;
89329   return jresult;
89330 }
89331
89332
89333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
89334   void * jresult ;
89335   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
89336
89337   {
89338     try {
89339       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
89340     } catch (std::out_of_range& e) {
89341       {
89342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89343       };
89344     } catch (std::exception& e) {
89345       {
89346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89347       };
89348     } catch (...) {
89349       {
89350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89351       };
89352     }
89353   }
89354   jresult = (void *)result;
89355   return jresult;
89356 }
89357
89358
89359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
89360   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
89361
89362   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
89363   {
89364     try {
89365       delete arg1;
89366     } catch (std::out_of_range& e) {
89367       {
89368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89369       };
89370     } catch (std::exception& e) {
89371       {
89372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89373       };
89374     } catch (...) {
89375       {
89376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89377       };
89378     }
89379   }
89380 }
89381
89382
89383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
89384   unsigned int jresult ;
89385   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89386   bool result;
89387
89388   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89389   {
89390     try {
89391       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89392     } catch (std::out_of_range& e) {
89393       {
89394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89395       };
89396     } catch (std::exception& e) {
89397       {
89398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89399       };
89400     } catch (...) {
89401       {
89402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89403       };
89404     }
89405   }
89406   jresult = result;
89407   return jresult;
89408 }
89409
89410
89411 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
89412   unsigned long jresult ;
89413   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89414   std::size_t result;
89415
89416   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89417   {
89418     try {
89419       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
89420     } catch (std::out_of_range& e) {
89421       {
89422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89423       };
89424     } catch (std::exception& e) {
89425       {
89426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89427       };
89428     } catch (...) {
89429       {
89430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89431       };
89432     }
89433   }
89434   jresult = (unsigned long)result;
89435   return jresult;
89436 }
89437
89438
89439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
89440   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89441   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89442
89443   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89444   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89445   {
89446     try {
89447       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
89448     } catch (std::out_of_range& e) {
89449       {
89450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89451       };
89452     } catch (std::exception& e) {
89453       {
89454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89455       };
89456     } catch (...) {
89457       {
89458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89459       };
89460     }
89461   }
89462 }
89463
89464
89465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
89466   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89467   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
89468
89469   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89470   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
89471   {
89472     try {
89473       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
89474     } catch (std::out_of_range& e) {
89475       {
89476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89477       };
89478     } catch (std::exception& e) {
89479       {
89480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89481       };
89482     } catch (...) {
89483       {
89484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89485       };
89486     }
89487   }
89488 }
89489
89490
89491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
89492   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89493   Dali::Toolkit::GaussianBlurView arg2 ;
89494   Dali::Toolkit::GaussianBlurView *argp2 ;
89495
89496   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89497   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89498   if (!argp2) {
89499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
89500     return ;
89501   }
89502   arg2 = *argp2;
89503   {
89504     try {
89505       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
89506     } catch (std::out_of_range& e) {
89507       {
89508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89509       };
89510     } catch (std::exception& e) {
89511       {
89512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89513       };
89514     } catch (...) {
89515       {
89516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89517       };
89518     }
89519   }
89520 }
89521
89522
89523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
89524   void * jresult ;
89525   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
89526
89527   {
89528     try {
89529       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
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 = (void *)result;
89545   return jresult;
89546 }
89547
89548
89549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
89550   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
89551
89552   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
89553   {
89554     try {
89555       delete arg1;
89556     } catch (std::out_of_range& e) {
89557       {
89558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89559       };
89560     } catch (std::exception& e) {
89561       {
89562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89563       };
89564     } catch (...) {
89565       {
89566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89567       };
89568     }
89569   }
89570 }
89571
89572
89573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
89574   unsigned int jresult ;
89575   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89576   bool result;
89577
89578   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89579   {
89580     try {
89581       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);
89582     } catch (std::out_of_range& e) {
89583       {
89584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89585       };
89586     } catch (std::exception& e) {
89587       {
89588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89589       };
89590     } catch (...) {
89591       {
89592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89593       };
89594     }
89595   }
89596   jresult = result;
89597   return jresult;
89598 }
89599
89600
89601 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
89602   unsigned long jresult ;
89603   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89604   std::size_t result;
89605
89606   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89607   {
89608     try {
89609       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);
89610     } catch (std::out_of_range& e) {
89611       {
89612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89613       };
89614     } catch (std::exception& e) {
89615       {
89616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89617       };
89618     } catch (...) {
89619       {
89620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89621       };
89622     }
89623   }
89624   jresult = (unsigned long)result;
89625   return jresult;
89626 }
89627
89628
89629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
89630   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89631   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89632
89633   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89634   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89635   {
89636     try {
89637       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
89638     } catch (std::out_of_range& e) {
89639       {
89640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89641       };
89642     } catch (std::exception& e) {
89643       {
89644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89645       };
89646     } catch (...) {
89647       {
89648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89649       };
89650     }
89651   }
89652 }
89653
89654
89655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
89656   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89657   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
89658
89659   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89660   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
89661   {
89662     try {
89663       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
89664     } catch (std::out_of_range& e) {
89665       {
89666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89667       };
89668     } catch (std::exception& e) {
89669       {
89670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89671       };
89672     } catch (...) {
89673       {
89674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89675       };
89676     }
89677   }
89678 }
89679
89680
89681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
89682   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89683   Dali::Toolkit::PageTurnView arg2 ;
89684   unsigned int arg3 ;
89685   bool arg4 ;
89686   Dali::Toolkit::PageTurnView *argp2 ;
89687
89688   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89689   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89690   if (!argp2) {
89691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89692     return ;
89693   }
89694   arg2 = *argp2;
89695   arg3 = (unsigned int)jarg3;
89696   arg4 = jarg4 ? true : false;
89697   {
89698     try {
89699       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
89700     } catch (std::out_of_range& e) {
89701       {
89702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89703       };
89704     } catch (std::exception& e) {
89705       {
89706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89707       };
89708     } catch (...) {
89709       {
89710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89711       };
89712     }
89713   }
89714 }
89715
89716
89717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
89718   void * jresult ;
89719   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
89720
89721   {
89722     try {
89723       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
89724     } catch (std::out_of_range& e) {
89725       {
89726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89727       };
89728     } catch (std::exception& e) {
89729       {
89730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89731       };
89732     } catch (...) {
89733       {
89734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89735       };
89736     }
89737   }
89738   jresult = (void *)result;
89739   return jresult;
89740 }
89741
89742
89743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
89744   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
89745
89746   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
89747   {
89748     try {
89749       delete arg1;
89750     } catch (std::out_of_range& e) {
89751       {
89752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89753       };
89754     } catch (std::exception& e) {
89755       {
89756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89757       };
89758     } catch (...) {
89759       {
89760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89761       };
89762     }
89763   }
89764 }
89765
89766
89767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
89768   unsigned int jresult ;
89769   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89770   bool result;
89771
89772   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89773   {
89774     try {
89775       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89776     } catch (std::out_of_range& e) {
89777       {
89778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89779       };
89780     } catch (std::exception& e) {
89781       {
89782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89783       };
89784     } catch (...) {
89785       {
89786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89787       };
89788     }
89789   }
89790   jresult = result;
89791   return jresult;
89792 }
89793
89794
89795 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
89796   unsigned long jresult ;
89797   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89798   std::size_t result;
89799
89800   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89801   {
89802     try {
89803       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
89804     } catch (std::out_of_range& e) {
89805       {
89806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89807       };
89808     } catch (std::exception& e) {
89809       {
89810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89811       };
89812     } catch (...) {
89813       {
89814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89815       };
89816     }
89817   }
89818   jresult = (unsigned long)result;
89819   return jresult;
89820 }
89821
89822
89823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
89824   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89825   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89826
89827   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89828   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89829   {
89830     try {
89831       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
89832     } catch (std::out_of_range& e) {
89833       {
89834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89835       };
89836     } catch (std::exception& e) {
89837       {
89838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89839       };
89840     } catch (...) {
89841       {
89842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89843       };
89844     }
89845   }
89846 }
89847
89848
89849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
89850   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89851   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
89852
89853   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89854   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
89855   {
89856     try {
89857       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
89858     } catch (std::out_of_range& e) {
89859       {
89860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89861       };
89862     } catch (std::exception& e) {
89863       {
89864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89865       };
89866     } catch (...) {
89867       {
89868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89869       };
89870     }
89871   }
89872 }
89873
89874
89875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
89876   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89877   Dali::Toolkit::PageTurnView arg2 ;
89878   Dali::Toolkit::PageTurnView *argp2 ;
89879
89880   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89881   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
89882   if (!argp2) {
89883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
89884     return ;
89885   }
89886   arg2 = *argp2;
89887   {
89888     try {
89889       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
89890     } catch (std::out_of_range& e) {
89891       {
89892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89893       };
89894     } catch (std::exception& e) {
89895       {
89896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89897       };
89898     } catch (...) {
89899       {
89900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89901       };
89902     }
89903   }
89904 }
89905
89906
89907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
89908   void * jresult ;
89909   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
89910
89911   {
89912     try {
89913       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
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 = (void *)result;
89929   return jresult;
89930 }
89931
89932
89933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
89934   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
89935
89936   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
89937   {
89938     try {
89939       delete arg1;
89940     } catch (std::out_of_range& e) {
89941       {
89942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89943       };
89944     } catch (std::exception& e) {
89945       {
89946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89947       };
89948     } catch (...) {
89949       {
89950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89951       };
89952     }
89953   }
89954 }
89955
89956
89957 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
89958   unsigned int jresult ;
89959   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89960   bool result;
89961
89962   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89963   {
89964     try {
89965       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);
89966     } catch (std::out_of_range& e) {
89967       {
89968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89969       };
89970     } catch (std::exception& e) {
89971       {
89972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89973       };
89974     } catch (...) {
89975       {
89976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89977       };
89978     }
89979   }
89980   jresult = result;
89981   return jresult;
89982 }
89983
89984
89985 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
89986   unsigned long jresult ;
89987   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
89988   std::size_t result;
89989
89990   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
89991   {
89992     try {
89993       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);
89994     } catch (std::out_of_range& e) {
89995       {
89996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89997       };
89998     } catch (std::exception& e) {
89999       {
90000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90001       };
90002     } catch (...) {
90003       {
90004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90005       };
90006     }
90007   }
90008   jresult = (unsigned long)result;
90009   return jresult;
90010 }
90011
90012
90013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
90014   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90015   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90016
90017   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90018   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90019   {
90020     try {
90021       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
90022     } catch (std::out_of_range& e) {
90023       {
90024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90025       };
90026     } catch (std::exception& e) {
90027       {
90028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90029       };
90030     } catch (...) {
90031       {
90032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90033       };
90034     }
90035   }
90036 }
90037
90038
90039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90040   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90041   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
90042
90043   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90044   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
90045   {
90046     try {
90047       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
90048     } catch (std::out_of_range& e) {
90049       {
90050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90051       };
90052     } catch (std::exception& e) {
90053       {
90054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90055       };
90056     } catch (...) {
90057       {
90058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90059       };
90060     }
90061   }
90062 }
90063
90064
90065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
90066   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90067   Dali::Toolkit::ProgressBar arg2 ;
90068   float arg3 ;
90069   float arg4 ;
90070   Dali::Toolkit::ProgressBar *argp2 ;
90071
90072   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90073   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
90074   if (!argp2) {
90075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
90076     return ;
90077   }
90078   arg2 = *argp2;
90079   arg3 = (float)jarg3;
90080   arg4 = (float)jarg4;
90081   {
90082     try {
90083       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
90084     } catch (std::out_of_range& e) {
90085       {
90086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90087       };
90088     } catch (std::exception& e) {
90089       {
90090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90091       };
90092     } catch (...) {
90093       {
90094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90095       };
90096     }
90097   }
90098 }
90099
90100
90101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
90102   void * jresult ;
90103   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
90104
90105   {
90106     try {
90107       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
90108     } catch (std::out_of_range& e) {
90109       {
90110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90111       };
90112     } catch (std::exception& e) {
90113       {
90114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90115       };
90116     } catch (...) {
90117       {
90118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90119       };
90120     }
90121   }
90122   jresult = (void *)result;
90123   return jresult;
90124 }
90125
90126
90127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
90128   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
90129
90130   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
90131   {
90132     try {
90133       delete arg1;
90134     } catch (std::out_of_range& e) {
90135       {
90136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90137       };
90138     } catch (std::exception& e) {
90139       {
90140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90141       };
90142     } catch (...) {
90143       {
90144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90145       };
90146     }
90147   }
90148 }
90149
90150
90151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
90152   unsigned int jresult ;
90153   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90154   bool result;
90155
90156   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90157   {
90158     try {
90159       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);
90160     } catch (std::out_of_range& e) {
90161       {
90162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90163       };
90164     } catch (std::exception& e) {
90165       {
90166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90167       };
90168     } catch (...) {
90169       {
90170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90171       };
90172     }
90173   }
90174   jresult = result;
90175   return jresult;
90176 }
90177
90178
90179 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
90180   unsigned long jresult ;
90181   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90182   std::size_t result;
90183
90184   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90185   {
90186     try {
90187       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);
90188     } catch (std::out_of_range& e) {
90189       {
90190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90191       };
90192     } catch (std::exception& e) {
90193       {
90194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90195       };
90196     } catch (...) {
90197       {
90198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90199       };
90200     }
90201   }
90202   jresult = (unsigned long)result;
90203   return jresult;
90204 }
90205
90206
90207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
90208   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90209   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90210
90211   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90212   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90213   {
90214     try {
90215       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90216     } catch (std::out_of_range& e) {
90217       {
90218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90219       };
90220     } catch (std::exception& e) {
90221       {
90222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90223       };
90224     } catch (...) {
90225       {
90226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90227       };
90228     }
90229   }
90230 }
90231
90232
90233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
90234   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90235   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
90236
90237   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90238   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
90239   {
90240     try {
90241       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90242     } catch (std::out_of_range& e) {
90243       {
90244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90245       };
90246     } catch (std::exception& e) {
90247       {
90248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90249       };
90250     } catch (...) {
90251       {
90252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90253       };
90254     }
90255   }
90256 }
90257
90258
90259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
90260   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90261   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
90262
90263   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90264   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
90265   if (!arg2) {
90266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
90267     return ;
90268   }
90269   {
90270     try {
90271       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
90272     } catch (std::out_of_range& e) {
90273       {
90274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90275       };
90276     } catch (std::exception& e) {
90277       {
90278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90279       };
90280     } catch (...) {
90281       {
90282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90283       };
90284     }
90285   }
90286 }
90287
90288
90289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
90290   void * jresult ;
90291   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
90292
90293   {
90294     try {
90295       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
90296     } catch (std::out_of_range& e) {
90297       {
90298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90299       };
90300     } catch (std::exception& e) {
90301       {
90302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90303       };
90304     } catch (...) {
90305       {
90306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90307       };
90308     }
90309   }
90310   jresult = (void *)result;
90311   return jresult;
90312 }
90313
90314
90315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
90316   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
90317
90318   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
90319   {
90320     try {
90321       delete arg1;
90322     } catch (std::out_of_range& e) {
90323       {
90324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90325       };
90326     } catch (std::exception& e) {
90327       {
90328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90329       };
90330     } catch (...) {
90331       {
90332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90333       };
90334     }
90335   }
90336 }
90337
90338
90339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
90340   unsigned int jresult ;
90341   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90342   bool result;
90343
90344   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90345   {
90346     try {
90347       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90348     } catch (std::out_of_range& e) {
90349       {
90350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90351       };
90352     } catch (std::exception& e) {
90353       {
90354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90355       };
90356     } catch (...) {
90357       {
90358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90359       };
90360     }
90361   }
90362   jresult = result;
90363   return jresult;
90364 }
90365
90366
90367 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
90368   unsigned long jresult ;
90369   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90370   std::size_t result;
90371
90372   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90373   {
90374     try {
90375       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
90376     } catch (std::out_of_range& e) {
90377       {
90378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90379       };
90380     } catch (std::exception& e) {
90381       {
90382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90383       };
90384     } catch (...) {
90385       {
90386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90387       };
90388     }
90389   }
90390   jresult = (unsigned long)result;
90391   return jresult;
90392 }
90393
90394
90395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
90396   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90397   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90398
90399   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90400   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90401   {
90402     try {
90403       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(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_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
90422   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90423   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
90424
90425   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90426   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
90427   {
90428     try {
90429       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90430     } catch (std::out_of_range& e) {
90431       {
90432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90433       };
90434     } catch (std::exception& e) {
90435       {
90436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90437       };
90438     } catch (...) {
90439       {
90440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90441       };
90442     }
90443   }
90444 }
90445
90446
90447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
90448   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90449   Dali::Vector2 *arg2 = 0 ;
90450
90451   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90452   arg2 = (Dali::Vector2 *)jarg2;
90453   if (!arg2) {
90454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90455     return ;
90456   }
90457   {
90458     try {
90459       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
90460     } catch (std::out_of_range& e) {
90461       {
90462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90463       };
90464     } catch (std::exception& e) {
90465       {
90466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90467       };
90468     } catch (...) {
90469       {
90470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90471       };
90472     }
90473   }
90474 }
90475
90476
90477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
90478   void * jresult ;
90479   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
90480
90481   {
90482     try {
90483       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
90484     } catch (std::out_of_range& e) {
90485       {
90486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90487       };
90488     } catch (std::exception& e) {
90489       {
90490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90491       };
90492     } catch (...) {
90493       {
90494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90495       };
90496     }
90497   }
90498   jresult = (void *)result;
90499   return jresult;
90500 }
90501
90502
90503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
90504   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
90505
90506   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
90507   {
90508     try {
90509       delete arg1;
90510     } catch (std::out_of_range& e) {
90511       {
90512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90513       };
90514     } catch (std::exception& e) {
90515       {
90516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90517       };
90518     } catch (...) {
90519       {
90520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90521       };
90522     }
90523   }
90524 }
90525
90526
90527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextEditorSignal_Empty(void * jarg1) {
90528   unsigned int jresult ;
90529   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90530   bool result;
90531
90532   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90533   {
90534     try {
90535       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90536     } catch (std::out_of_range& e) {
90537       {
90538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90539       };
90540     } catch (std::exception& e) {
90541       {
90542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90543       };
90544     } catch (...) {
90545       {
90546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90547       };
90548     }
90549   }
90550   jresult = result;
90551   return jresult;
90552 }
90553
90554
90555 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextEditorSignal_GetConnectionCount(void * jarg1) {
90556   unsigned long jresult ;
90557   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90558   std::size_t result;
90559
90560   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90561   {
90562     try {
90563       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextEditor) > const *)arg1);
90564     } catch (std::out_of_range& e) {
90565       {
90566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90567       };
90568     } catch (std::exception& e) {
90569       {
90570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90571       };
90572     } catch (...) {
90573       {
90574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90575       };
90576     }
90577   }
90578   jresult = (unsigned long)result;
90579   return jresult;
90580 }
90581
90582
90583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Connect(void * jarg1, void * jarg2) {
90584   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90585   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90586
90587   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90588   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90589   {
90590     try {
90591       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Connect(arg1,arg2);
90592     } catch (std::out_of_range& e) {
90593       {
90594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90595       };
90596     } catch (std::exception& e) {
90597       {
90598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90599       };
90600     } catch (...) {
90601       {
90602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90603       };
90604     }
90605   }
90606 }
90607
90608
90609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Disconnect(void * jarg1, void * jarg2) {
90610   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90611   void (*arg2)(Dali::Toolkit::TextEditor) = (void (*)(Dali::Toolkit::TextEditor)) 0 ;
90612
90613   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90614   arg2 = (void (*)(Dali::Toolkit::TextEditor))jarg2;
90615   {
90616     try {
90617       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Disconnect(arg1,arg2);
90618     } catch (std::out_of_range& e) {
90619       {
90620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90621       };
90622     } catch (std::exception& e) {
90623       {
90624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90625       };
90626     } catch (...) {
90627       {
90628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90629       };
90630     }
90631   }
90632 }
90633
90634
90635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextEditorSignal_Emit(void * jarg1, void * jarg2) {
90636   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90637   Dali::Toolkit::TextEditor arg2 ;
90638   Dali::Toolkit::TextEditor *argp2 ;
90639
90640   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90641   argp2 = (Dali::Toolkit::TextEditor *)jarg2;
90642   if (!argp2) {
90643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextEditor", 0);
90644     return ;
90645   }
90646   arg2 = *argp2;
90647   {
90648     try {
90649       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextEditor_SP__Sg__Emit(arg1,arg2);
90650     } catch (std::out_of_range& e) {
90651       {
90652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90653       };
90654     } catch (std::exception& e) {
90655       {
90656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90657       };
90658     } catch (...) {
90659       {
90660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90661       };
90662     }
90663   }
90664 }
90665
90666
90667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextEditorSignal() {
90668   void * jresult ;
90669   Dali::Signal< void (Dali::Toolkit::TextEditor) > *result = 0 ;
90670
90671   {
90672     try {
90673       result = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)new Dali::Signal< void (Dali::Toolkit::TextEditor) >();
90674     } catch (std::out_of_range& e) {
90675       {
90676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90677       };
90678     } catch (std::exception& e) {
90679       {
90680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90681       };
90682     } catch (...) {
90683       {
90684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90685       };
90686     }
90687   }
90688   jresult = (void *)result;
90689   return jresult;
90690 }
90691
90692
90693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextEditorSignal(void * jarg1) {
90694   Dali::Signal< void (Dali::Toolkit::TextEditor) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *) 0 ;
90695
90696   arg1 = (Dali::Signal< void (Dali::Toolkit::TextEditor) > *)jarg1;
90697   {
90698     try {
90699       delete arg1;
90700     } catch (std::out_of_range& e) {
90701       {
90702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90703       };
90704     } catch (std::exception& e) {
90705       {
90706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90707       };
90708     } catch (...) {
90709       {
90710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90711       };
90712     }
90713   }
90714 }
90715
90716
90717 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TextFieldSignal_Empty(void * jarg1) {
90718   unsigned int jresult ;
90719   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90720   bool result;
90721
90722   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90723   {
90724     try {
90725       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90726     } catch (std::out_of_range& e) {
90727       {
90728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90729       };
90730     } catch (std::exception& e) {
90731       {
90732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90733       };
90734     } catch (...) {
90735       {
90736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90737       };
90738     }
90739   }
90740   jresult = result;
90741   return jresult;
90742 }
90743
90744
90745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextFieldSignal_GetConnectionCount(void * jarg1) {
90746   unsigned long jresult ;
90747   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90748   std::size_t result;
90749
90750   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90751   {
90752     try {
90753       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::TextField) > const *)arg1);
90754     } catch (std::out_of_range& e) {
90755       {
90756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90757       };
90758     } catch (std::exception& e) {
90759       {
90760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90761       };
90762     } catch (...) {
90763       {
90764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90765       };
90766     }
90767   }
90768   jresult = (unsigned long)result;
90769   return jresult;
90770 }
90771
90772
90773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Connect(void * jarg1, void * jarg2) {
90774   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90775   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90776
90777   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90778   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90779   {
90780     try {
90781       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Connect(arg1,arg2);
90782     } catch (std::out_of_range& e) {
90783       {
90784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90785       };
90786     } catch (std::exception& e) {
90787       {
90788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90789       };
90790     } catch (...) {
90791       {
90792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90793       };
90794     }
90795   }
90796 }
90797
90798
90799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Disconnect(void * jarg1, void * jarg2) {
90800   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90801   void (*arg2)(Dali::Toolkit::TextField) = (void (*)(Dali::Toolkit::TextField)) 0 ;
90802
90803   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90804   arg2 = (void (*)(Dali::Toolkit::TextField))jarg2;
90805   {
90806     try {
90807       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Disconnect(arg1,arg2);
90808     } catch (std::out_of_range& e) {
90809       {
90810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90811       };
90812     } catch (std::exception& e) {
90813       {
90814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90815       };
90816     } catch (...) {
90817       {
90818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90819       };
90820     }
90821   }
90822 }
90823
90824
90825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextFieldSignal_Emit(void * jarg1, void * jarg2) {
90826   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90827   Dali::Toolkit::TextField arg2 ;
90828   Dali::Toolkit::TextField *argp2 ;
90829
90830   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90831   argp2 = (Dali::Toolkit::TextField *)jarg2;
90832   if (!argp2) {
90833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TextField", 0);
90834     return ;
90835   }
90836   arg2 = *argp2;
90837   {
90838     try {
90839       Dali_Signal_Sl_void_Sp_Dali_Toolkit_TextField_SP__Sg__Emit(arg1,arg2);
90840     } catch (std::out_of_range& e) {
90841       {
90842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90843       };
90844     } catch (std::exception& e) {
90845       {
90846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90847       };
90848     } catch (...) {
90849       {
90850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90851       };
90852     }
90853   }
90854 }
90855
90856
90857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextFieldSignal() {
90858   void * jresult ;
90859   Dali::Signal< void (Dali::Toolkit::TextField) > *result = 0 ;
90860
90861   {
90862     try {
90863       result = (Dali::Signal< void (Dali::Toolkit::TextField) > *)new Dali::Signal< void (Dali::Toolkit::TextField) >();
90864     } catch (std::out_of_range& e) {
90865       {
90866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90867       };
90868     } catch (std::exception& e) {
90869       {
90870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90871       };
90872     } catch (...) {
90873       {
90874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90875       };
90876     }
90877   }
90878   jresult = (void *)result;
90879   return jresult;
90880 }
90881
90882
90883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextFieldSignal(void * jarg1) {
90884   Dali::Signal< void (Dali::Toolkit::TextField) > *arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *) 0 ;
90885
90886   arg1 = (Dali::Signal< void (Dali::Toolkit::TextField) > *)jarg1;
90887   {
90888     try {
90889       delete arg1;
90890     } catch (std::out_of_range& e) {
90891       {
90892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90893       };
90894     } catch (std::exception& e) {
90895       {
90896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90897       };
90898     } catch (...) {
90899       {
90900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90901       };
90902     }
90903   }
90904 }
90905
90906
90907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
90908   unsigned int jresult ;
90909   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90910   bool result;
90911
90912   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90913   {
90914     try {
90915       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);
90916     } catch (std::out_of_range& e) {
90917       {
90918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90919       };
90920     } catch (std::exception& e) {
90921       {
90922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90923       };
90924     } catch (...) {
90925       {
90926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90927       };
90928     }
90929   }
90930   jresult = result;
90931   return jresult;
90932 }
90933
90934
90935 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
90936   unsigned long jresult ;
90937   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90938   std::size_t result;
90939
90940   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90941   {
90942     try {
90943       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);
90944     } catch (std::out_of_range& e) {
90945       {
90946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90947       };
90948     } catch (std::exception& e) {
90949       {
90950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90951       };
90952     } catch (...) {
90953       {
90954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90955       };
90956     }
90957   }
90958   jresult = (unsigned long)result;
90959   return jresult;
90960 }
90961
90962
90963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
90964   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90965   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90966
90967   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90968   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90969   {
90970     try {
90971       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
90972     } catch (std::out_of_range& e) {
90973       {
90974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90975       };
90976     } catch (std::exception& e) {
90977       {
90978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90979       };
90980     } catch (...) {
90981       {
90982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90983       };
90984     }
90985   }
90986 }
90987
90988
90989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
90990   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
90991   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
90992
90993   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
90994   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
90995   {
90996     try {
90997       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
90998     } catch (std::out_of_range& e) {
90999       {
91000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91001       };
91002     } catch (std::exception& e) {
91003       {
91004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91005       };
91006     } catch (...) {
91007       {
91008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91009       };
91010     }
91011   }
91012 }
91013
91014
91015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
91016   unsigned int jresult ;
91017   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91018   Dali::Toolkit::Control arg2 ;
91019   Dali::KeyEvent *arg3 = 0 ;
91020   Dali::Toolkit::Control *argp2 ;
91021   bool result;
91022
91023   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91024   argp2 = (Dali::Toolkit::Control *)jarg2;
91025   if (!argp2) {
91026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91027     return 0;
91028   }
91029   arg2 = *argp2;
91030   arg3 = (Dali::KeyEvent *)jarg3;
91031   if (!arg3) {
91032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
91033     return 0;
91034   }
91035   {
91036     try {
91037       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);
91038     } catch (std::out_of_range& e) {
91039       {
91040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91041       };
91042     } catch (std::exception& e) {
91043       {
91044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91045       };
91046     } catch (...) {
91047       {
91048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91049       };
91050     }
91051   }
91052   jresult = result;
91053   return jresult;
91054 }
91055
91056
91057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
91058   void * jresult ;
91059   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
91060
91061   {
91062     try {
91063       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
91064     } catch (std::out_of_range& e) {
91065       {
91066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91067       };
91068     } catch (std::exception& e) {
91069       {
91070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91071       };
91072     } catch (...) {
91073       {
91074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91075       };
91076     }
91077   }
91078   jresult = (void *)result;
91079   return jresult;
91080 }
91081
91082
91083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
91084   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
91085
91086   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
91087   {
91088     try {
91089       delete arg1;
91090     } catch (std::out_of_range& e) {
91091       {
91092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91093       };
91094     } catch (std::exception& e) {
91095       {
91096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91097       };
91098     } catch (...) {
91099       {
91100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91101       };
91102     }
91103   }
91104 }
91105
91106
91107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
91108   unsigned int jresult ;
91109   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91110   bool result;
91111
91112   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91113   {
91114     try {
91115       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91116     } catch (std::out_of_range& e) {
91117       {
91118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91119       };
91120     } catch (std::exception& e) {
91121       {
91122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91123       };
91124     } catch (...) {
91125       {
91126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91127       };
91128     }
91129   }
91130   jresult = result;
91131   return jresult;
91132 }
91133
91134
91135 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
91136   unsigned long jresult ;
91137   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91138   std::size_t result;
91139
91140   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91141   {
91142     try {
91143       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
91144     } catch (std::out_of_range& e) {
91145       {
91146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91147       };
91148     } catch (std::exception& e) {
91149       {
91150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91151       };
91152     } catch (...) {
91153       {
91154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91155       };
91156     }
91157   }
91158   jresult = (unsigned long)result;
91159   return jresult;
91160 }
91161
91162
91163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
91164   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91165   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91166
91167   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91168   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91169   {
91170     try {
91171       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(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_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
91190   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91191   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
91192
91193   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91194   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
91195   {
91196     try {
91197       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
91198     } catch (std::out_of_range& e) {
91199       {
91200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91201       };
91202     } catch (std::exception& e) {
91203       {
91204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91205       };
91206     } catch (...) {
91207       {
91208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91209       };
91210     }
91211   }
91212 }
91213
91214
91215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
91216   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91217   Dali::Toolkit::Control arg2 ;
91218   Dali::Toolkit::Control *argp2 ;
91219
91220   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91221   argp2 = (Dali::Toolkit::Control *)jarg2;
91222   if (!argp2) {
91223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
91224     return ;
91225   }
91226   arg2 = *argp2;
91227   {
91228     try {
91229       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
91230     } catch (std::out_of_range& e) {
91231       {
91232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91233       };
91234     } catch (std::exception& e) {
91235       {
91236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91237       };
91238     } catch (...) {
91239       {
91240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91241       };
91242     }
91243   }
91244 }
91245
91246
91247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
91248   void * jresult ;
91249   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
91250
91251   {
91252     try {
91253       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
91254     } catch (std::out_of_range& e) {
91255       {
91256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91257       };
91258     } catch (std::exception& e) {
91259       {
91260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91261       };
91262     } catch (...) {
91263       {
91264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91265       };
91266     }
91267   }
91268   jresult = (void *)result;
91269   return jresult;
91270 }
91271
91272
91273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
91274   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
91275
91276   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
91277   {
91278     try {
91279       delete arg1;
91280     } catch (std::out_of_range& e) {
91281       {
91282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91283       };
91284     } catch (std::exception& e) {
91285       {
91286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91287       };
91288     } catch (...) {
91289       {
91290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91291       };
91292     }
91293   }
91294 }
91295
91296
91297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
91298   unsigned int jresult ;
91299   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91300   bool result;
91301
91302   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91303   {
91304     try {
91305       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91306     } catch (std::out_of_range& e) {
91307       {
91308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91309       };
91310     } catch (std::exception& e) {
91311       {
91312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91313       };
91314     } catch (...) {
91315       {
91316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91317       };
91318     }
91319   }
91320   jresult = result;
91321   return jresult;
91322 }
91323
91324
91325 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
91326   unsigned long jresult ;
91327   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91328   std::size_t result;
91329
91330   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91331   {
91332     try {
91333       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
91334     } catch (std::out_of_range& e) {
91335       {
91336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91337       };
91338     } catch (std::exception& e) {
91339       {
91340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91341       };
91342     } catch (...) {
91343       {
91344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91345       };
91346     }
91347   }
91348   jresult = (unsigned long)result;
91349   return jresult;
91350 }
91351
91352
91353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
91354   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91355   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91356
91357   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91358   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91359   {
91360     try {
91361       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
91362     } catch (std::out_of_range& e) {
91363       {
91364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91365       };
91366     } catch (std::exception& e) {
91367       {
91368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91369       };
91370     } catch (...) {
91371       {
91372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91373       };
91374     }
91375   }
91376 }
91377
91378
91379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
91380   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91381   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
91382
91383   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91384   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
91385   {
91386     try {
91387       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
91388     } catch (std::out_of_range& e) {
91389       {
91390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91391       };
91392     } catch (std::exception& e) {
91393       {
91394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91395       };
91396     } catch (...) {
91397       {
91398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91399       };
91400     }
91401   }
91402 }
91403
91404
91405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
91406   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91407   Dali::Toolkit::VideoView *arg2 = 0 ;
91408
91409   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91410   arg2 = (Dali::Toolkit::VideoView *)jarg2;
91411   if (!arg2) {
91412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
91413     return ;
91414   }
91415   {
91416     try {
91417       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
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 void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
91436   void * jresult ;
91437   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
91438
91439   {
91440     try {
91441       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
91442     } catch (std::out_of_range& e) {
91443       {
91444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91445       };
91446     } catch (std::exception& e) {
91447       {
91448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91449       };
91450     } catch (...) {
91451       {
91452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91453       };
91454     }
91455   }
91456   jresult = (void *)result;
91457   return jresult;
91458 }
91459
91460
91461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
91462   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
91463
91464   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
91465   {
91466     try {
91467       delete arg1;
91468     } catch (std::out_of_range& e) {
91469       {
91470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91471       };
91472     } catch (std::exception& e) {
91473       {
91474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91475       };
91476     } catch (...) {
91477       {
91478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91479       };
91480     }
91481   }
91482 }
91483
91484
91485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
91486   unsigned int jresult ;
91487   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91488   bool result;
91489
91490   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91491   {
91492     try {
91493       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91494     } catch (std::out_of_range& e) {
91495       {
91496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91497       };
91498     } catch (std::exception& e) {
91499       {
91500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91501       };
91502     } catch (...) {
91503       {
91504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91505       };
91506     }
91507   }
91508   jresult = result;
91509   return jresult;
91510 }
91511
91512
91513 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
91514   unsigned long jresult ;
91515   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91516   std::size_t result;
91517
91518   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91519   {
91520     try {
91521       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
91522     } catch (std::out_of_range& e) {
91523       {
91524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91525       };
91526     } catch (std::exception& e) {
91527       {
91528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91529       };
91530     } catch (...) {
91531       {
91532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91533       };
91534     }
91535   }
91536   jresult = (unsigned long)result;
91537   return jresult;
91538 }
91539
91540
91541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91542   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91543   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91544
91545   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91546   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91547   {
91548     try {
91549       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
91550     } catch (std::out_of_range& e) {
91551       {
91552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91553       };
91554     } catch (std::exception& e) {
91555       {
91556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91557       };
91558     } catch (...) {
91559       {
91560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91561       };
91562     }
91563   }
91564 }
91565
91566
91567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91568   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91569   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
91570
91571   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91572   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
91573   {
91574     try {
91575       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91576     } catch (std::out_of_range& e) {
91577       {
91578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91579       };
91580     } catch (std::exception& e) {
91581       {
91582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91583       };
91584     } catch (...) {
91585       {
91586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91587       };
91588     }
91589   }
91590 }
91591
91592
91593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
91594   unsigned int jresult ;
91595   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91596   Dali::Toolkit::Slider arg2 ;
91597   float arg3 ;
91598   Dali::Toolkit::Slider *argp2 ;
91599   bool result;
91600
91601   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91602   argp2 = (Dali::Toolkit::Slider *)jarg2;
91603   if (!argp2) {
91604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91605     return 0;
91606   }
91607   arg2 = *argp2;
91608   arg3 = (float)jarg3;
91609   {
91610     try {
91611       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
91612     } catch (std::out_of_range& e) {
91613       {
91614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91615       };
91616     } catch (std::exception& e) {
91617       {
91618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91619       };
91620     } catch (...) {
91621       {
91622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91623       };
91624     }
91625   }
91626   jresult = result;
91627   return jresult;
91628 }
91629
91630
91631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
91632   void * jresult ;
91633   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
91634
91635   {
91636     try {
91637       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
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_delete_SliderValueChangedSignal(void * jarg1) {
91658   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
91659
91660   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
91661   {
91662     try {
91663       delete arg1;
91664     } catch (std::out_of_range& e) {
91665       {
91666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91667       };
91668     } catch (std::exception& e) {
91669       {
91670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91671       };
91672     } catch (...) {
91673       {
91674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91675       };
91676     }
91677   }
91678 }
91679
91680
91681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
91682   unsigned int jresult ;
91683   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91684   bool result;
91685
91686   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91687   {
91688     try {
91689       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91690     } catch (std::out_of_range& e) {
91691       {
91692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91693       };
91694     } catch (std::exception& e) {
91695       {
91696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91697       };
91698     } catch (...) {
91699       {
91700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91701       };
91702     }
91703   }
91704   jresult = result;
91705   return jresult;
91706 }
91707
91708
91709 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
91710   unsigned long jresult ;
91711   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91712   std::size_t result;
91713
91714   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91715   {
91716     try {
91717       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
91718     } catch (std::out_of_range& e) {
91719       {
91720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91721       };
91722     } catch (std::exception& e) {
91723       {
91724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91725       };
91726     } catch (...) {
91727       {
91728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91729       };
91730     }
91731   }
91732   jresult = (unsigned long)result;
91733   return jresult;
91734 }
91735
91736
91737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
91738   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91739   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91740
91741   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91742   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91743   {
91744     try {
91745       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
91746     } catch (std::out_of_range& e) {
91747       {
91748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91749       };
91750     } catch (std::exception& e) {
91751       {
91752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91753       };
91754     } catch (...) {
91755       {
91756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91757       };
91758     }
91759   }
91760 }
91761
91762
91763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
91764   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91765   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
91766
91767   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91768   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
91769   {
91770     try {
91771       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
91772     } catch (std::out_of_range& e) {
91773       {
91774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91775       };
91776     } catch (std::exception& e) {
91777       {
91778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91779       };
91780     } catch (...) {
91781       {
91782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91783       };
91784     }
91785   }
91786 }
91787
91788
91789 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91790   unsigned int jresult ;
91791   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91792   Dali::Toolkit::Slider arg2 ;
91793   int arg3 ;
91794   Dali::Toolkit::Slider *argp2 ;
91795   bool result;
91796
91797   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91798   argp2 = (Dali::Toolkit::Slider *)jarg2;
91799   if (!argp2) {
91800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
91801     return 0;
91802   }
91803   arg2 = *argp2;
91804   arg3 = (int)jarg3;
91805   {
91806     try {
91807       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
91808     } catch (std::out_of_range& e) {
91809       {
91810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91811       };
91812     } catch (std::exception& e) {
91813       {
91814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91815       };
91816     } catch (...) {
91817       {
91818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91819       };
91820     }
91821   }
91822   jresult = result;
91823   return jresult;
91824 }
91825
91826
91827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
91828   void * jresult ;
91829   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
91830
91831   {
91832     try {
91833       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
91834     } catch (std::out_of_range& e) {
91835       {
91836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91837       };
91838     } catch (std::exception& e) {
91839       {
91840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91841       };
91842     } catch (...) {
91843       {
91844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91845       };
91846     }
91847   }
91848   jresult = (void *)result;
91849   return jresult;
91850 }
91851
91852
91853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
91854   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
91855
91856   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
91857   {
91858     try {
91859       delete arg1;
91860     } catch (std::out_of_range& e) {
91861       {
91862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91863       };
91864     } catch (std::exception& e) {
91865       {
91866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91867       };
91868     } catch (...) {
91869       {
91870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91871       };
91872     }
91873   }
91874 }
91875
91876
91877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
91878   void * jresult ;
91879   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91880
91881   {
91882     try {
91883       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
91884     } catch (std::out_of_range& e) {
91885       {
91886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91887       };
91888     } catch (std::exception& e) {
91889       {
91890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91891       };
91892     } catch (...) {
91893       {
91894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91895       };
91896     }
91897   }
91898   jresult = (void *)result;
91899   return jresult;
91900 }
91901
91902
91903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
91904   void * jresult ;
91905   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
91906   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91907
91908   arg1 = (Dali::Toolkit::Ruler *)jarg1;
91909   {
91910     try {
91911       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
91912     } catch (std::out_of_range& e) {
91913       {
91914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91915       };
91916     } catch (std::exception& e) {
91917       {
91918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91919       };
91920     } catch (...) {
91921       {
91922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91923       };
91924     }
91925   }
91926   jresult = (void *)result;
91927   return jresult;
91928 }
91929
91930
91931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
91932   void * jresult ;
91933   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
91934   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
91935
91936   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91937   if (!arg1) {
91938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
91939     return 0;
91940   }
91941   {
91942     try {
91943       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
91944     } catch (std::out_of_range& e) {
91945       {
91946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91947       };
91948     } catch (std::exception& e) {
91949       {
91950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91951       };
91952     } catch (...) {
91953       {
91954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91955       };
91956     }
91957   }
91958   jresult = (void *)result;
91959   return jresult;
91960 }
91961
91962
91963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
91964   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91965
91966   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91967   {
91968     try {
91969       delete arg1;
91970     } catch (std::out_of_range& e) {
91971       {
91972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91973       };
91974     } catch (std::exception& e) {
91975       {
91976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91977       };
91978     } catch (...) {
91979       {
91980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91981       };
91982     }
91983   }
91984 }
91985
91986
91987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
91988   void * jresult ;
91989   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
91990   Dali::Toolkit::Ruler *result = 0 ;
91991
91992   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
91993   {
91994     try {
91995       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
91996     } catch (std::out_of_range& e) {
91997       {
91998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91999       };
92000     } catch (std::exception& e) {
92001       {
92002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92003       };
92004     } catch (...) {
92005       {
92006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92007       };
92008     }
92009   }
92010   jresult = (void *)result;
92011   return jresult;
92012 }
92013
92014
92015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
92016   void * jresult ;
92017   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92018   Dali::Toolkit::Ruler *result = 0 ;
92019
92020   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92021   {
92022     try {
92023       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
92024     } catch (std::out_of_range& e) {
92025       {
92026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92027       };
92028     } catch (std::exception& e) {
92029       {
92030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92031       };
92032     } catch (...) {
92033       {
92034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92035       };
92036     }
92037   }
92038   jresult = (void *)result;
92039   return jresult;
92040 }
92041
92042
92043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
92044   void * jresult ;
92045   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92046   Dali::Toolkit::Ruler *result = 0 ;
92047
92048   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92049   {
92050     try {
92051       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
92052     } catch (std::out_of_range& e) {
92053       {
92054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92055       };
92056     } catch (std::exception& e) {
92057       {
92058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92059       };
92060     } catch (...) {
92061       {
92062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92063       };
92064     }
92065   }
92066   jresult = (void *)result;
92067   return jresult;
92068 }
92069
92070
92071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
92072   void * jresult ;
92073   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92074   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
92075   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92076
92077   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92078   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
92079   if (!arg2) {
92080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
92081     return 0;
92082   }
92083   {
92084     try {
92085       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
92086     } catch (std::out_of_range& e) {
92087       {
92088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92089       };
92090     } catch (std::exception& e) {
92091       {
92092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92093       };
92094     } catch (...) {
92095       {
92096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92097       };
92098     }
92099   }
92100   jresult = (void *)result;
92101   return jresult;
92102 }
92103
92104
92105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
92106   void * jresult ;
92107   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92108   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92109   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
92110
92111   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92112   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92113   {
92114     try {
92115       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
92116     } catch (std::out_of_range& e) {
92117       {
92118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92119       };
92120     } catch (std::exception& e) {
92121       {
92122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92123       };
92124     } catch (...) {
92125       {
92126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92127       };
92128     }
92129   }
92130   jresult = (void *)result;
92131   return jresult;
92132 }
92133
92134
92135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
92136   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92137
92138   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92139   {
92140     try {
92141       (arg1)->Reset();
92142     } catch (std::out_of_range& e) {
92143       {
92144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92145       };
92146     } catch (std::exception& e) {
92147       {
92148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92149       };
92150     } catch (...) {
92151       {
92152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92153       };
92154     }
92155   }
92156 }
92157
92158
92159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
92160   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92161   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
92162
92163   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92164   arg2 = (Dali::Toolkit::Ruler *)jarg2;
92165   {
92166     try {
92167       (arg1)->Reset(arg2);
92168     } catch (std::out_of_range& e) {
92169       {
92170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92171       };
92172     } catch (std::exception& e) {
92173       {
92174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92175       };
92176     } catch (...) {
92177       {
92178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92179       };
92180     }
92181   }
92182 }
92183
92184
92185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
92186   void * jresult ;
92187   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92188   Dali::Toolkit::Ruler *result = 0 ;
92189
92190   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92191   {
92192     try {
92193       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
92194     } catch (std::out_of_range& e) {
92195       {
92196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92197       };
92198     } catch (std::exception& e) {
92199       {
92200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92201       };
92202     } catch (...) {
92203       {
92204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92205       };
92206     }
92207   }
92208   jresult = (void *)result;
92209   return jresult;
92210 }
92211
92212
92213 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
92214   float jresult ;
92215   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92216   float arg2 ;
92217   float arg3 ;
92218   float result;
92219
92220   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92221   arg2 = (float)jarg2;
92222   arg3 = (float)jarg3;
92223   {
92224     try {
92225       result = (float)(*arg1)->Snap(arg2,arg3);
92226     } catch (std::out_of_range& e) {
92227       {
92228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92229       };
92230     } catch (std::exception& e) {
92231       {
92232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92233       };
92234     } catch (...) {
92235       {
92236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92237       };
92238     }
92239   }
92240   jresult = result;
92241   return jresult;
92242 }
92243
92244
92245 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
92246   float jresult ;
92247   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92248   float arg2 ;
92249   float result;
92250
92251   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92252   arg2 = (float)jarg2;
92253   {
92254     try {
92255       result = (float)(*arg1)->Snap(arg2);
92256     } catch (std::out_of_range& e) {
92257       {
92258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92259       };
92260     } catch (std::exception& e) {
92261       {
92262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92263       };
92264     } catch (...) {
92265       {
92266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92267       };
92268     }
92269   }
92270   jresult = result;
92271   return jresult;
92272 }
92273
92274
92275 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
92276   float jresult ;
92277   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92278   unsigned int arg2 ;
92279   unsigned int *arg3 = 0 ;
92280   bool arg4 ;
92281   float result;
92282
92283   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92284   arg2 = (unsigned int)jarg2;
92285   arg3 = (unsigned int *)jarg3;
92286   arg4 = jarg4 ? true : false;
92287   {
92288     try {
92289       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
92290     } catch (std::out_of_range& e) {
92291       {
92292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92293       };
92294     } catch (std::exception& e) {
92295       {
92296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92297       };
92298     } catch (...) {
92299       {
92300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92301       };
92302     }
92303   }
92304   jresult = result;
92305   return jresult;
92306 }
92307
92308
92309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
92310   unsigned int jresult ;
92311   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92312   float arg2 ;
92313   bool arg3 ;
92314   unsigned int result;
92315
92316   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92317   arg2 = (float)jarg2;
92318   arg3 = jarg3 ? true : false;
92319   {
92320     try {
92321       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
92322     } catch (std::out_of_range& e) {
92323       {
92324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92325       };
92326     } catch (std::exception& e) {
92327       {
92328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92329       };
92330     } catch (...) {
92331       {
92332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92333       };
92334     }
92335   }
92336   jresult = result;
92337   return jresult;
92338 }
92339
92340
92341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
92342   unsigned int jresult ;
92343   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92344   unsigned int result;
92345
92346   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92347   {
92348     try {
92349       result = (unsigned int)(*arg1)->GetTotalPages();
92350     } catch (std::out_of_range& e) {
92351       {
92352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92353       };
92354     } catch (std::exception& e) {
92355       {
92356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92357       };
92358     } catch (...) {
92359       {
92360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92361       };
92362     }
92363   }
92364   jresult = result;
92365   return jresult;
92366 }
92367
92368
92369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
92370   int jresult ;
92371   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92372   Dali::Toolkit::Ruler::RulerType result;
92373
92374   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92375   {
92376     try {
92377       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
92378     } catch (std::out_of_range& e) {
92379       {
92380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92381       };
92382     } catch (std::exception& e) {
92383       {
92384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92385       };
92386     } catch (...) {
92387       {
92388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92389       };
92390     }
92391   }
92392   jresult = (int)result;
92393   return jresult;
92394 }
92395
92396
92397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
92398   unsigned int jresult ;
92399   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92400   bool result;
92401
92402   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92403   {
92404     try {
92405       result = (bool)(*arg1)->IsEnabled();
92406     } catch (std::out_of_range& e) {
92407       {
92408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92409       };
92410     } catch (std::exception& e) {
92411       {
92412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92413       };
92414     } catch (...) {
92415       {
92416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92417       };
92418     }
92419   }
92420   jresult = result;
92421   return jresult;
92422 }
92423
92424
92425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
92426   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92427
92428   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92429   {
92430     try {
92431       (*arg1)->Enable();
92432     } catch (std::out_of_range& e) {
92433       {
92434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92435       };
92436     } catch (std::exception& e) {
92437       {
92438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92439       };
92440     } catch (...) {
92441       {
92442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92443       };
92444     }
92445   }
92446 }
92447
92448
92449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
92450   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92451
92452   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92453   {
92454     try {
92455       (*arg1)->Disable();
92456     } catch (std::out_of_range& e) {
92457       {
92458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92459       };
92460     } catch (std::exception& e) {
92461       {
92462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92463       };
92464     } catch (...) {
92465       {
92466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92467       };
92468     }
92469   }
92470 }
92471
92472
92473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
92474   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92475   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
92476   Dali::Toolkit::RulerDomain *argp2 ;
92477
92478   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92479   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
92480   if (!argp2) {
92481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
92482     return ;
92483   }
92484   arg2 = *argp2;
92485   {
92486     try {
92487       (*arg1)->SetDomain(arg2);
92488     } catch (std::out_of_range& e) {
92489       {
92490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92491       };
92492     } catch (std::exception& e) {
92493       {
92494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92495       };
92496     } catch (...) {
92497       {
92498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92499       };
92500     }
92501   }
92502 }
92503
92504
92505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
92506   void * jresult ;
92507   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92508   Dali::Toolkit::RulerDomain *result = 0 ;
92509
92510   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92511   {
92512     try {
92513       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
92514     } catch (std::out_of_range& e) {
92515       {
92516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92517       };
92518     } catch (std::exception& e) {
92519       {
92520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92521       };
92522     } catch (...) {
92523       {
92524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92525       };
92526     }
92527   }
92528   jresult = (void *)result;
92529   return jresult;
92530 }
92531
92532
92533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
92534   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92535
92536   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92537   {
92538     try {
92539       (*arg1)->DisableDomain();
92540     } catch (std::out_of_range& e) {
92541       {
92542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92543       };
92544     } catch (std::exception& e) {
92545       {
92546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92547       };
92548     } catch (...) {
92549       {
92550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92551       };
92552     }
92553   }
92554 }
92555
92556
92557 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
92558   float jresult ;
92559   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92560   float arg2 ;
92561   float arg3 ;
92562   float arg4 ;
92563   float result;
92564
92565   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92566   arg2 = (float)jarg2;
92567   arg3 = (float)jarg3;
92568   arg4 = (float)jarg4;
92569   {
92570     try {
92571       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
92572     } catch (std::out_of_range& e) {
92573       {
92574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92575       };
92576     } catch (std::exception& e) {
92577       {
92578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92579       };
92580     } catch (...) {
92581       {
92582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92583       };
92584     }
92585   }
92586   jresult = result;
92587   return jresult;
92588 }
92589
92590
92591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
92592   float jresult ;
92593   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92594   float arg2 ;
92595   float arg3 ;
92596   float result;
92597
92598   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92599   arg2 = (float)jarg2;
92600   arg3 = (float)jarg3;
92601   {
92602     try {
92603       result = (float)(*arg1)->Clamp(arg2,arg3);
92604     } catch (std::out_of_range& e) {
92605       {
92606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92607       };
92608     } catch (std::exception& e) {
92609       {
92610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92611       };
92612     } catch (...) {
92613       {
92614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92615       };
92616     }
92617   }
92618   jresult = result;
92619   return jresult;
92620 }
92621
92622
92623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
92624   float jresult ;
92625   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92626   float arg2 ;
92627   float result;
92628
92629   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92630   arg2 = (float)jarg2;
92631   {
92632     try {
92633       result = (float)(*arg1)->Clamp(arg2);
92634     } catch (std::out_of_range& e) {
92635       {
92636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92637       };
92638     } catch (std::exception& e) {
92639       {
92640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92641       };
92642     } catch (...) {
92643       {
92644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92645       };
92646     }
92647   }
92648   jresult = result;
92649   return jresult;
92650 }
92651
92652
92653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
92654   float jresult ;
92655   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92656   float arg2 ;
92657   float arg3 ;
92658   float arg4 ;
92659   Dali::Toolkit::ClampState *arg5 = 0 ;
92660   float result;
92661
92662   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92663   arg2 = (float)jarg2;
92664   arg3 = (float)jarg3;
92665   arg4 = (float)jarg4;
92666   arg5 = (Dali::Toolkit::ClampState *)jarg5;
92667   if (!arg5) {
92668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92669     return 0;
92670   }
92671   {
92672     try {
92673       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
92674     } catch (std::out_of_range& e) {
92675       {
92676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92677       };
92678     } catch (std::exception& e) {
92679       {
92680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92681       };
92682     } catch (...) {
92683       {
92684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92685       };
92686     }
92687   }
92688   jresult = result;
92689   return jresult;
92690 }
92691
92692
92693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
92694   float jresult ;
92695   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92696   float arg2 ;
92697   float arg3 ;
92698   float arg4 ;
92699   float arg5 ;
92700   float result;
92701
92702   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92703   arg2 = (float)jarg2;
92704   arg3 = (float)jarg3;
92705   arg4 = (float)jarg4;
92706   arg5 = (float)jarg5;
92707   {
92708     try {
92709       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
92710     } catch (std::out_of_range& e) {
92711       {
92712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92713       };
92714     } catch (std::exception& e) {
92715       {
92716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92717       };
92718     } catch (...) {
92719       {
92720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92721       };
92722     }
92723   }
92724   jresult = result;
92725   return jresult;
92726 }
92727
92728
92729 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
92730   float jresult ;
92731   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92732   float arg2 ;
92733   float arg3 ;
92734   float arg4 ;
92735   float result;
92736
92737   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92738   arg2 = (float)jarg2;
92739   arg3 = (float)jarg3;
92740   arg4 = (float)jarg4;
92741   {
92742     try {
92743       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
92744     } catch (std::out_of_range& e) {
92745       {
92746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92747       };
92748     } catch (std::exception& e) {
92749       {
92750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92751       };
92752     } catch (...) {
92753       {
92754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92755       };
92756     }
92757   }
92758   jresult = result;
92759   return jresult;
92760 }
92761
92762
92763 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
92764   float jresult ;
92765   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92766   float arg2 ;
92767   float arg3 ;
92768   float result;
92769
92770   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92771   arg2 = (float)jarg2;
92772   arg3 = (float)jarg3;
92773   {
92774     try {
92775       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
92776     } catch (std::out_of_range& e) {
92777       {
92778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92779       };
92780     } catch (std::exception& e) {
92781       {
92782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92783       };
92784     } catch (...) {
92785       {
92786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92787       };
92788     }
92789   }
92790   jresult = result;
92791   return jresult;
92792 }
92793
92794
92795 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
92796   float jresult ;
92797   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92798   float arg2 ;
92799   float result;
92800
92801   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92802   arg2 = (float)jarg2;
92803   {
92804     try {
92805       result = (float)(*arg1)->SnapAndClamp(arg2);
92806     } catch (std::out_of_range& e) {
92807       {
92808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92809       };
92810     } catch (std::exception& e) {
92811       {
92812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92813       };
92814     } catch (...) {
92815       {
92816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92817       };
92818     }
92819   }
92820   jresult = result;
92821   return jresult;
92822 }
92823
92824
92825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
92826   float jresult ;
92827   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92828   float arg2 ;
92829   float arg3 ;
92830   float arg4 ;
92831   float arg5 ;
92832   Dali::Toolkit::ClampState *arg6 = 0 ;
92833   float result;
92834
92835   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92836   arg2 = (float)jarg2;
92837   arg3 = (float)jarg3;
92838   arg4 = (float)jarg4;
92839   arg5 = (float)jarg5;
92840   arg6 = (Dali::Toolkit::ClampState *)jarg6;
92841   if (!arg6) {
92842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
92843     return 0;
92844   }
92845   {
92846     try {
92847       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
92848     } catch (std::out_of_range& e) {
92849       {
92850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92851       };
92852     } catch (std::exception& e) {
92853       {
92854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92855       };
92856     } catch (...) {
92857       {
92858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92859       };
92860     }
92861   }
92862   jresult = result;
92863   return jresult;
92864 }
92865
92866
92867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
92868   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92869
92870   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92871   {
92872     try {
92873       (*arg1)->Reference();
92874     } catch (std::out_of_range& e) {
92875       {
92876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92877       };
92878     } catch (std::exception& e) {
92879       {
92880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92881       };
92882     } catch (...) {
92883       {
92884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92885       };
92886     }
92887   }
92888 }
92889
92890
92891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
92892   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92893
92894   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92895   {
92896     try {
92897       (*arg1)->Unreference();
92898     } catch (std::out_of_range& e) {
92899       {
92900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92901       };
92902     } catch (std::exception& e) {
92903       {
92904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92905       };
92906     } catch (...) {
92907       {
92908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92909       };
92910     }
92911   }
92912 }
92913
92914
92915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
92916   int jresult ;
92917   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
92918   int result;
92919
92920   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
92921   {
92922     try {
92923       result = (int)(*arg1)->ReferenceCount();
92924     } catch (std::out_of_range& e) {
92925       {
92926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92927       };
92928     } catch (std::exception& e) {
92929       {
92930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92931       };
92932     } catch (...) {
92933       {
92934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92935       };
92936     }
92937   }
92938   jresult = result;
92939   return jresult;
92940 }
92941
92942
92943 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
92944     return (Dali::RefObject *)jarg1;
92945 }
92946
92947 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
92948     return (Dali::SignalObserver *)jarg1;
92949 }
92950
92951 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
92952     return (Dali::ConnectionTrackerInterface *)jarg1;
92953 }
92954
92955 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
92956     return (Dali::BaseHandle *)jarg1;
92957 }
92958
92959 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
92960     return (Dali::BaseHandle *)jarg1;
92961 }
92962
92963 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
92964     return (Dali::BaseHandle *)jarg1;
92965 }
92966
92967 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
92968     return (Dali::BaseHandle *)jarg1;
92969 }
92970
92971 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
92972     return (Dali::BaseHandle *)jarg1;
92973 }
92974
92975 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
92976     return (Dali::BaseHandle *)jarg1;
92977 }
92978
92979 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
92980     return (Dali::BaseHandle *)jarg1;
92981 }
92982
92983 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
92984     return (Dali::BaseHandle *)jarg1;
92985 }
92986
92987 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
92988     return (Dali::BaseHandle *)jarg1;
92989 }
92990
92991 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
92992     return (Dali::BaseHandle *)jarg1;
92993 }
92994
92995 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
92996     return (Dali::BaseHandle *)jarg1;
92997 }
92998
92999 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
93000     return (Dali::BaseHandle *)jarg1;
93001 }
93002
93003 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
93004     return (Dali::BaseHandle *)jarg1;
93005 }
93006
93007 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
93008     return (Dali::Handle *)jarg1;
93009 }
93010
93011 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
93012     return (Dali::Handle *)jarg1;
93013 }
93014
93015 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
93016     return (Dali::BaseHandle *)jarg1;
93017 }
93018
93019 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
93020     return (Dali::BaseHandle *)jarg1;
93021 }
93022
93023 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
93024     return (Dali::Handle *)jarg1;
93025 }
93026
93027 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
93028     return (Dali::BaseHandle *)jarg1;
93029 }
93030
93031 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
93032     return (Dali::Handle *)jarg1;
93033 }
93034
93035 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
93036     return (Dali::GestureDetector *)jarg1;
93037 }
93038
93039 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
93040     return (Dali::Gesture *)jarg1;
93041 }
93042
93043 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
93044     return (Dali::Handle *)jarg1;
93045 }
93046
93047 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
93048     return (Dali::Actor *)jarg1;
93049 }
93050
93051 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
93052     return (Dali::BaseHandle *)jarg1;
93053 }
93054
93055 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
93056     return (Dali::RefObject *)jarg1;
93057 }
93058
93059 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
93060     return (Dali::Actor *)jarg1;
93061 }
93062
93063 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
93064     return (Dali::GestureDetector *)jarg1;
93065 }
93066
93067 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
93068     return (Dali::Gesture *)jarg1;
93069 }
93070
93071 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
93072     return (Dali::GestureDetector *)jarg1;
93073 }
93074
93075 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
93076     return (Dali::Gesture *)jarg1;
93077 }
93078
93079 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
93080     return (Dali::GestureDetector *)jarg1;
93081 }
93082
93083 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
93084     return (Dali::Gesture *)jarg1;
93085 }
93086
93087 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
93088     return (Dali::BaseHandle *)jarg1;
93089 }
93090
93091 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
93092     return (Dali::Handle *)jarg1;
93093 }
93094
93095 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Animation_SWIGUpcast(Dali::Animation *jarg1) {
93096     return (Dali::BaseHandle *)jarg1;
93097 }
93098
93099 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
93100     return (Dali::Handle *)jarg1;
93101 }
93102
93103 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
93104     return (Dali::Handle *)jarg1;
93105 }
93106
93107 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
93108     return (Dali::Image *)jarg1;
93109 }
93110
93111 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
93112     return (Dali::Image *)jarg1;
93113 }
93114
93115 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
93116     return (Dali::Image *)jarg1;
93117 }
93118
93119 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
93120     return (Dali::RefObject *)jarg1;
93121 }
93122
93123 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
93124     return (Dali::Image *)jarg1;
93125 }
93126
93127 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
93128     return (Dali::Image *)jarg1;
93129 }
93130
93131 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
93132     return (Dali::ResourceImage *)jarg1;
93133 }
93134
93135 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
93136     return (Dali::Actor *)jarg1;
93137 }
93138
93139 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
93140     return (Dali::BaseHandle *)jarg1;
93141 }
93142
93143 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
93144     return (Dali::BaseHandle *)jarg1;
93145 }
93146
93147 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Window_SWIGUpcast(Dali::Window *jarg1) {
93148     return (Dali::BaseHandle *)jarg1;
93149 }
93150
93151 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Application_SWIGUpcast(Dali::Application *jarg1) {
93152     return (Dali::BaseHandle *)jarg1;
93153 }
93154
93155 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
93156     return (Dali::BaseHandle *)jarg1;
93157 }
93158
93159 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
93160     return (Dali::BaseHandle *)jarg1;
93161 }
93162
93163 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
93164     return (Dali::CustomActorImpl *)jarg1;
93165 }
93166
93167 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
93168     return (Dali::CustomActor *)jarg1;
93169 }
93170
93171 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
93172     return (Dali::BaseHandle *)jarg1;
93173 }
93174
93175 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
93176     return (Dali::Toolkit::Control *)jarg1;
93177 }
93178
93179 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
93180     return (Dali::Toolkit::Control *)jarg1;
93181 }
93182
93183 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
93184     return (Dali::Toolkit::Button *)jarg1;
93185 }
93186
93187 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
93188     return (Dali::Toolkit::Button *)jarg1;
93189 }
93190
93191 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
93192     return (Dali::Toolkit::Button *)jarg1;
93193 }
93194
93195 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
93196     return (Dali::Toolkit::Control *)jarg1;
93197 }
93198
93199 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
93200     return (Dali::Toolkit::Control *)jarg1;
93201 }
93202
93203 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
93204     return (Dali::Toolkit::Control *)jarg1;
93205 }
93206
93207 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
93208     return (Dali::Toolkit::Control *)jarg1;
93209 }
93210
93211 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
93212     return (Dali::Toolkit::Control *)jarg1;
93213 }
93214
93215 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
93216     return (Dali::RefObject *)jarg1;
93217 }
93218
93219 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
93220     return (Dali::Toolkit::Scrollable *)jarg1;
93221 }
93222
93223 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
93224     return (Dali::BaseHandle *)jarg1;
93225 }
93226
93227 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
93228     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
93229 }
93230
93231 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
93232     return (Dali::RefObject *)jarg1;
93233 }
93234
93235 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
93236     return (Dali::Toolkit::Ruler *)jarg1;
93237 }
93238
93239 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
93240     return (Dali::Toolkit::Ruler *)jarg1;
93241 }
93242
93243 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
93244     return (Dali::Toolkit::Scrollable *)jarg1;
93245 }
93246
93247 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
93248     return (Dali::Toolkit::Control *)jarg1;
93249 }
93250
93251 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextEditor_SWIGUpcast(Dali::Toolkit::TextEditor *jarg1) {
93252     return (Dali::Toolkit::Control *)jarg1;
93253 }
93254
93255 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextField_SWIGUpcast(Dali::Toolkit::TextField *jarg1) {
93256     return (Dali::Toolkit::Control *)jarg1;
93257 }
93258
93259 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
93260     return (Dali::Toolkit::Control *)jarg1;
93261 }
93262
93263 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
93264     return (Dali::BaseHandle *)jarg1;
93265 }
93266
93267 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
93268     return (Dali::BaseHandle *)jarg1;
93269 }
93270
93271 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
93272     return (Dali::Toolkit::Control *)jarg1;
93273 }
93274
93275 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
93276     return (Dali::Toolkit::Control *)jarg1;
93277 }
93278
93279 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
93280     return (Dali::Toolkit::Control *)jarg1;
93281 }
93282
93283 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
93284     return (Dali::Toolkit::Control *)jarg1;
93285 }
93286
93287 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
93288     return (Dali::Toolkit::Control *)jarg1;
93289 }
93290
93291 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
93292     return (Dali::Toolkit::Control *)jarg1;
93293 }
93294
93295 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
93296     return (Dali::Toolkit::PageTurnView *)jarg1;
93297 }
93298
93299 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
93300     return (Dali::Toolkit::PageTurnView *)jarg1;
93301 }
93302
93303 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
93304     return (Dali::Toolkit::Button *)jarg1;
93305 }
93306
93307 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
93308     return (Dali::BaseHandle *)jarg1;
93309 }
93310
93311 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
93312     return (Dali::BaseHandle *)jarg1;
93313 }
93314
93315 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
93316     return (Dali::BaseHandle *)jarg1;
93317 }
93318
93319
93320
93321
93322
93323 //////////////////////////////////////////////////
93324 //from dali-swig autogeneration (from dali_wrap.cpp)
93325
93326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_0() {
93327   void * jresult ;
93328   Dali::ImfManager::ImfEventData *result = 0 ;
93329
93330   {
93331     try {
93332       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData();
93333     } catch (std::out_of_range& e) {
93334       {
93335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93336       };
93337     } catch (std::exception& e) {
93338       {
93339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93340       };
93341     } catch (...) {
93342       {
93343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93344       };
93345     }
93346   }
93347   jresult = (void *)result;
93348   return jresult;
93349 }
93350
93351
93352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfEventData__SWIG_1(int jarg1, char * jarg2, int jarg3, int jarg4) {
93353   void * jresult ;
93354   Dali::ImfManager::ImfEvent arg1 ;
93355   std::string *arg2 = 0 ;
93356   int arg3 ;
93357   int arg4 ;
93358   Dali::ImfManager::ImfEventData *result = 0 ;
93359
93360   arg1 = (Dali::ImfManager::ImfEvent)jarg1;
93361   if (!jarg2) {
93362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
93363     return 0;
93364   }
93365   std::string arg2_str(jarg2);
93366   arg2 = &arg2_str;
93367   arg3 = (int)jarg3;
93368   arg4 = (int)jarg4;
93369   {
93370     try {
93371       result = (Dali::ImfManager::ImfEventData *)new Dali::ImfManager::ImfEventData(arg1,(std::string const &)*arg2,arg3,arg4);
93372     } catch (std::out_of_range& e) {
93373       {
93374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93375       };
93376     } catch (std::exception& e) {
93377       {
93378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93379       };
93380     } catch (...) {
93381       {
93382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93383       };
93384     }
93385   }
93386   jresult = (void *)result;
93387
93388   //argout typemap for const std::string&
93389
93390   return jresult;
93391 }
93392
93393
93394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_set(void * jarg1, char * jarg2) {
93395   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93396   std::string *arg2 = 0 ;
93397
93398   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93399   if (!jarg2) {
93400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
93401     return ;
93402   }
93403   std::string arg2_str(jarg2);
93404   arg2 = &arg2_str;
93405   if (arg1) (arg1)->predictiveString = *arg2;
93406
93407   //argout typemap for const std::string&
93408
93409 }
93410
93411
93412 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_predictiveString_get(void * jarg1) {
93413   char * jresult ;
93414   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93415   std::string *result = 0 ;
93416
93417   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93418   result = (std::string *) & ((arg1)->predictiveString);
93419   jresult = SWIG_csharp_string_callback(result->c_str());
93420   return jresult;
93421 }
93422
93423
93424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_set(void * jarg1, int jarg2) {
93425   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93426   Dali::ImfManager::ImfEvent arg2 ;
93427
93428   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93429   arg2 = (Dali::ImfManager::ImfEvent)jarg2;
93430   if (arg1) (arg1)->eventName = arg2;
93431 }
93432
93433
93434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_eventName_get(void * jarg1) {
93435   int jresult ;
93436   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93437   Dali::ImfManager::ImfEvent result;
93438
93439   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93440   result = (Dali::ImfManager::ImfEvent) ((arg1)->eventName);
93441   jresult = (int)result;
93442   return jresult;
93443 }
93444
93445
93446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_set(void * jarg1, int jarg2) {
93447   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93448   int arg2 ;
93449
93450   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93451   arg2 = (int)jarg2;
93452   if (arg1) (arg1)->cursorOffset = arg2;
93453 }
93454
93455
93456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_cursorOffset_get(void * jarg1) {
93457   int jresult ;
93458   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93459   int result;
93460
93461   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93462   result = (int) ((arg1)->cursorOffset);
93463   jresult = result;
93464   return jresult;
93465 }
93466
93467
93468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_set(void * jarg1, int jarg2) {
93469   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93470   int arg2 ;
93471
93472   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93473   arg2 = (int)jarg2;
93474   if (arg1) (arg1)->numberOfChars = arg2;
93475 }
93476
93477
93478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfEventData_numberOfChars_get(void * jarg1) {
93479   int jresult ;
93480   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93481   int result;
93482
93483   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93484   result = (int) ((arg1)->numberOfChars);
93485   jresult = result;
93486   return jresult;
93487 }
93488
93489
93490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfEventData(void * jarg1) {
93491   Dali::ImfManager::ImfEventData *arg1 = (Dali::ImfManager::ImfEventData *) 0 ;
93492
93493   arg1 = (Dali::ImfManager::ImfEventData *)jarg1;
93494   {
93495     try {
93496       delete arg1;
93497     } catch (std::out_of_range& e) {
93498       {
93499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93500       };
93501     } catch (std::exception& e) {
93502       {
93503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93504       };
93505     } catch (...) {
93506       {
93507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93508       };
93509     }
93510   }
93511 }
93512
93513
93514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_0() {
93515   void * jresult ;
93516   Dali::ImfManager::ImfCallbackData *result = 0 ;
93517
93518   {
93519     try {
93520       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData();
93521     } catch (std::out_of_range& e) {
93522       {
93523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93524       };
93525     } catch (std::exception& e) {
93526       {
93527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93528       };
93529     } catch (...) {
93530       {
93531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93532       };
93533     }
93534   }
93535   jresult = (void *)result;
93536   return jresult;
93537 }
93538
93539
93540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager_ImfCallbackData__SWIG_1(unsigned int jarg1, int jarg2, char * jarg3, unsigned int jarg4) {
93541   void * jresult ;
93542   bool arg1 ;
93543   int arg2 ;
93544   std::string *arg3 = 0 ;
93545   bool arg4 ;
93546   Dali::ImfManager::ImfCallbackData *result = 0 ;
93547
93548   arg1 = jarg1 ? true : false;
93549   arg2 = (int)jarg2;
93550   if (!jarg3) {
93551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
93552     return 0;
93553   }
93554   std::string arg3_str(jarg3);
93555   arg3 = &arg3_str;
93556   arg4 = jarg4 ? true : false;
93557   {
93558     try {
93559       result = (Dali::ImfManager::ImfCallbackData *)new Dali::ImfManager::ImfCallbackData(arg1,arg2,(std::string const &)*arg3,arg4);
93560     } catch (std::out_of_range& e) {
93561       {
93562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93563       };
93564     } catch (std::exception& e) {
93565       {
93566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93567       };
93568     } catch (...) {
93569       {
93570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93571       };
93572     }
93573   }
93574   jresult = (void *)result;
93575
93576   //argout typemap for const std::string&
93577
93578   return jresult;
93579 }
93580
93581
93582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_set(void * jarg1, char * jarg2) {
93583   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
93584   std::string *arg2 = 0 ;
93585
93586   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
93587   if (!jarg2) {
93588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
93589     return ;
93590   }
93591   std::string arg2_str(jarg2);
93592   arg2 = &arg2_str;
93593   if (arg1) (arg1)->currentText = *arg2;
93594
93595   //argout typemap for const std::string&
93596
93597 }
93598
93599
93600 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_currentText_get(void * jarg1) {
93601   char * jresult ;
93602   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
93603   std::string *result = 0 ;
93604
93605   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
93606   result = (std::string *) & ((arg1)->currentText);
93607   jresult = SWIG_csharp_string_callback(result->c_str());
93608   return jresult;
93609 }
93610
93611
93612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_set(void * jarg1, int jarg2) {
93613   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
93614   int arg2 ;
93615
93616   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
93617   arg2 = (int)jarg2;
93618   if (arg1) (arg1)->cursorPosition = arg2;
93619 }
93620
93621
93622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_cursorPosition_get(void * jarg1) {
93623   int jresult ;
93624   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
93625   int result;
93626
93627   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
93628   result = (int) ((arg1)->cursorPosition);
93629   jresult = result;
93630   return jresult;
93631 }
93632
93633
93634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_set(void * jarg1, unsigned int jarg2) {
93635   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
93636   bool arg2 ;
93637
93638   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
93639   arg2 = jarg2 ? true : false;
93640   if (arg1) (arg1)->update = arg2;
93641 }
93642
93643
93644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_update_get(void * jarg1) {
93645   unsigned int jresult ;
93646   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
93647   bool result;
93648
93649   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
93650   result = (bool) ((arg1)->update);
93651   jresult = result;
93652   return jresult;
93653 }
93654
93655
93656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_set(void * jarg1, unsigned int jarg2) {
93657   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
93658   bool arg2 ;
93659
93660   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
93661   arg2 = jarg2 ? true : false;
93662   if (arg1) (arg1)->preeditResetRequired = arg2;
93663 }
93664
93665
93666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_ImfCallbackData_preeditResetRequired_get(void * jarg1) {
93667   unsigned int jresult ;
93668   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
93669   bool result;
93670
93671   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
93672   result = (bool) ((arg1)->preeditResetRequired);
93673   jresult = result;
93674   return jresult;
93675 }
93676
93677
93678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager_ImfCallbackData(void * jarg1) {
93679   Dali::ImfManager::ImfCallbackData *arg1 = (Dali::ImfManager::ImfCallbackData *) 0 ;
93680
93681   arg1 = (Dali::ImfManager::ImfCallbackData *)jarg1;
93682   {
93683     try {
93684       delete arg1;
93685     } catch (std::out_of_range& e) {
93686       {
93687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93688       };
93689     } catch (std::exception& e) {
93690       {
93691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93692       };
93693     } catch (...) {
93694       {
93695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93696       };
93697     }
93698   }
93699 }
93700
93701
93702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_Get() {
93703   void * jresult ;
93704   Dali::ImfManager result;
93705
93706   {
93707     try {
93708       result = Dali::ImfManager::Get();
93709     } catch (std::out_of_range& e) {
93710       {
93711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93712       };
93713     } catch (std::exception& e) {
93714       {
93715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93716       };
93717     } catch (...) {
93718       {
93719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93720       };
93721     }
93722   }
93723   jresult = new Dali::ImfManager((const Dali::ImfManager &)result);
93724   return jresult;
93725 }
93726
93727
93728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Activate(void * jarg1) {
93729   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
93730
93731   arg1 = (Dali::ImfManager *)jarg1;
93732   {
93733     try {
93734       (arg1)->Activate();
93735     } catch (std::out_of_range& e) {
93736       {
93737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93738       };
93739     } catch (std::exception& e) {
93740       {
93741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93742       };
93743     } catch (...) {
93744       {
93745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93746       };
93747     }
93748   }
93749 }
93750
93751
93752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Deactivate(void * jarg1) {
93753   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
93754
93755   arg1 = (Dali::ImfManager *)jarg1;
93756   {
93757     try {
93758       (arg1)->Deactivate();
93759     } catch (std::out_of_range& e) {
93760       {
93761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93762       };
93763     } catch (std::exception& e) {
93764       {
93765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93766       };
93767     } catch (...) {
93768       {
93769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93770       };
93771     }
93772   }
93773 }
93774
93775
93776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_RestoreAfterFocusLost(void * jarg1) {
93777   unsigned int jresult ;
93778   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
93779   bool result;
93780
93781   arg1 = (Dali::ImfManager *)jarg1;
93782   {
93783     try {
93784       result = (bool)((Dali::ImfManager const *)arg1)->RestoreAfterFocusLost();
93785     } catch (std::out_of_range& e) {
93786       {
93787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93788       };
93789     } catch (std::exception& e) {
93790       {
93791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93792       };
93793     } catch (...) {
93794       {
93795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93796       };
93797     }
93798   }
93799   jresult = result;
93800   return jresult;
93801 }
93802
93803
93804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetRestoreAfterFocusLost(void * jarg1, unsigned int jarg2) {
93805   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
93806   bool arg2 ;
93807
93808   arg1 = (Dali::ImfManager *)jarg1;
93809   arg2 = jarg2 ? true : false;
93810   {
93811     try {
93812       (arg1)->SetRestoreAfterFocusLost(arg2);
93813     } catch (std::out_of_range& e) {
93814       {
93815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93816       };
93817     } catch (std::exception& e) {
93818       {
93819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93820       };
93821     } catch (...) {
93822       {
93823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93824       };
93825     }
93826   }
93827 }
93828
93829
93830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_Reset(void * jarg1) {
93831   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
93832
93833   arg1 = (Dali::ImfManager *)jarg1;
93834   {
93835     try {
93836       (arg1)->Reset();
93837     } catch (std::out_of_range& e) {
93838       {
93839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93840       };
93841     } catch (std::exception& e) {
93842       {
93843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93844       };
93845     } catch (...) {
93846       {
93847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93848       };
93849     }
93850   }
93851 }
93852
93853
93854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyCursorPosition(void * jarg1) {
93855   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
93856
93857   arg1 = (Dali::ImfManager *)jarg1;
93858   {
93859     try {
93860       (arg1)->NotifyCursorPosition();
93861     } catch (std::out_of_range& e) {
93862       {
93863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93864       };
93865     } catch (std::exception& e) {
93866       {
93867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93868       };
93869     } catch (...) {
93870       {
93871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93872       };
93873     }
93874   }
93875 }
93876
93877
93878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetCursorPosition(void * jarg1, unsigned int jarg2) {
93879   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
93880   unsigned int arg2 ;
93881
93882   arg1 = (Dali::ImfManager *)jarg1;
93883   arg2 = (unsigned int)jarg2;
93884   {
93885     try {
93886       (arg1)->SetCursorPosition(arg2);
93887     } catch (std::out_of_range& e) {
93888       {
93889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93890       };
93891     } catch (std::exception& e) {
93892       {
93893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93894       };
93895     } catch (...) {
93896       {
93897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93898       };
93899     }
93900   }
93901 }
93902
93903
93904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImfManager_GetCursorPosition(void * jarg1) {
93905   unsigned int jresult ;
93906   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
93907   unsigned int result;
93908
93909   arg1 = (Dali::ImfManager *)jarg1;
93910   {
93911     try {
93912       result = (unsigned int)((Dali::ImfManager const *)arg1)->GetCursorPosition();
93913     } catch (std::out_of_range& e) {
93914       {
93915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93916       };
93917     } catch (std::exception& e) {
93918       {
93919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93920       };
93921     } catch (...) {
93922       {
93923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93924       };
93925     }
93926   }
93927   jresult = result;
93928   return jresult;
93929 }
93930
93931
93932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetSurroundingText(void * jarg1, char * jarg2) {
93933   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
93934   std::string *arg2 = 0 ;
93935
93936   arg1 = (Dali::ImfManager *)jarg1;
93937   if (!jarg2) {
93938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
93939     return ;
93940   }
93941   std::string arg2_str(jarg2);
93942   arg2 = &arg2_str;
93943   {
93944     try {
93945       (arg1)->SetSurroundingText((std::string const &)*arg2);
93946     } catch (std::out_of_range& e) {
93947       {
93948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93949       };
93950     } catch (std::exception& e) {
93951       {
93952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93953       };
93954     } catch (...) {
93955       {
93956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93957       };
93958     }
93959   }
93960
93961   //argout typemap for const std::string&
93962
93963 }
93964
93965
93966 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ImfManager_GetSurroundingText(void * jarg1) {
93967   char * jresult ;
93968   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
93969   std::string *result = 0 ;
93970
93971   arg1 = (Dali::ImfManager *)jarg1;
93972   {
93973     try {
93974       result = (std::string *) &((Dali::ImfManager const *)arg1)->GetSurroundingText();
93975     } catch (std::out_of_range& e) {
93976       {
93977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93978       };
93979     } catch (std::exception& e) {
93980       {
93981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93982       };
93983     } catch (...) {
93984       {
93985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93986       };
93987     }
93988   }
93989   jresult = SWIG_csharp_string_callback(result->c_str());
93990   return jresult;
93991 }
93992
93993
93994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_NotifyTextInputMultiLine(void * jarg1, unsigned int jarg2) {
93995   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
93996   bool arg2 ;
93997
93998   arg1 = (Dali::ImfManager *)jarg1;
93999   arg2 = jarg2 ? true : false;
94000   {
94001     try {
94002       (arg1)->NotifyTextInputMultiLine(arg2);
94003     } catch (std::out_of_range& e) {
94004       {
94005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94006       };
94007     } catch (std::exception& e) {
94008       {
94009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94010       };
94011     } catch (...) {
94012       {
94013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94014       };
94015     }
94016   }
94017 }
94018
94019
94020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetTextDirection(void * jarg1) {
94021   int jresult ;
94022   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94023   Dali::ImfManager::TextDirection result;
94024
94025   arg1 = (Dali::ImfManager *)jarg1;
94026   {
94027     try {
94028       result = (Dali::ImfManager::TextDirection)(arg1)->GetTextDirection();
94029     } catch (std::out_of_range& e) {
94030       {
94031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94032       };
94033     } catch (std::exception& e) {
94034       {
94035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94036       };
94037     } catch (...) {
94038       {
94039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94040       };
94041     }
94042   }
94043   jresult = (int)result;
94044   return jresult;
94045 }
94046
94047
94048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_GetInputMethodArea(void * jarg1) {
94049   void * jresult ;
94050   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94051   Dali::Rect< int > result;
94052
94053   arg1 = (Dali::ImfManager *)jarg1;
94054   {
94055     try {
94056       result = (arg1)->GetInputMethodArea();
94057     } catch (std::out_of_range& e) {
94058       {
94059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94060       };
94061     } catch (std::exception& e) {
94062       {
94063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94064       };
94065     } catch (...) {
94066       {
94067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94068       };
94069     }
94070   }
94071   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
94072   return jresult;
94073 }
94074
94075
94076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ApplyOptions(void * jarg1, void * jarg2) {
94077   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94078   Dali::InputMethodOptions *arg2 = 0 ;
94079
94080   arg1 = (Dali::ImfManager *)jarg1;
94081   arg2 = (Dali::InputMethodOptions *)jarg2;
94082   if (!arg2) {
94083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "InputMethodOptions const & type is null", 0);
94084     return ;
94085   }
94086   {
94087     try {
94088       (arg1)->ApplyOptions((Dali::InputMethodOptions const &)*arg2);
94089     } catch (std::out_of_range& e) {
94090       {
94091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94092       };
94093     } catch (std::exception& e) {
94094       {
94095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94096       };
94097     } catch (...) {
94098       {
94099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94100       };
94101     }
94102   }
94103 }
94104
94105
94106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetInputPanelUserData(void * jarg1, char * jarg2) {
94107   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94108   std::string *arg2 = 0 ;
94109
94110   arg1 = (Dali::ImfManager *)jarg1;
94111   if (!jarg2) {
94112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94113     return ;
94114   }
94115   std::string arg2_str(jarg2);
94116   arg2 = &arg2_str;
94117   {
94118     try {
94119       (arg1)->SetInputPanelUserData((std::string const &)*arg2);
94120     } catch (std::out_of_range& e) {
94121       {
94122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94123       };
94124     } catch (std::exception& e) {
94125       {
94126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94127       };
94128     } catch (...) {
94129       {
94130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94131       };
94132     }
94133   }
94134
94135   //argout typemap for const std::string&
94136
94137 }
94138
94139
94140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelUserData(void * jarg1, char * jarg2) {
94141   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94142   std::string *arg2 = 0 ;
94143
94144   arg1 = (Dali::ImfManager *)jarg1;
94145   if (!jarg2) {
94146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
94147     return ;
94148   }
94149   std::string arg2_str(jarg2);
94150   arg2 = &arg2_str;
94151   {
94152     try {
94153       (arg1)->GetInputPanelUserData((std::string &)*arg2);
94154     } catch (std::out_of_range& e) {
94155       {
94156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94157       };
94158     } catch (std::exception& e) {
94159       {
94160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94161       };
94162     } catch (...) {
94163       {
94164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94165       };
94166     }
94167   }
94168
94169 }
94170
94171
94172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImfManager_GetInputPanelState(void * jarg1) {
94173   int jresult ;
94174   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94175   Dali::ImfManager::State result;
94176
94177   arg1 = (Dali::ImfManager *)jarg1;
94178   {
94179     try {
94180       result = (Dali::ImfManager::State)(arg1)->GetInputPanelState();
94181     } catch (std::out_of_range& e) {
94182       {
94183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94184       };
94185     } catch (std::exception& e) {
94186       {
94187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94188       };
94189     } catch (...) {
94190       {
94191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94192       };
94193     }
94194   }
94195   jresult = (int)result;
94196   return jresult;
94197 }
94198
94199
94200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_SetReturnKeyState(void * jarg1, unsigned int jarg2) {
94201   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94202   bool arg2 ;
94203
94204   arg1 = (Dali::ImfManager *)jarg1;
94205   arg2 = jarg2 ? true : false;
94206   {
94207     try {
94208       (arg1)->SetReturnKeyState(arg2);
94209     } catch (std::out_of_range& e) {
94210       {
94211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94212       };
94213     } catch (std::exception& e) {
94214       {
94215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94216       };
94217     } catch (...) {
94218       {
94219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94220       };
94221     }
94222   }
94223 }
94224
94225
94226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_AutoEnableInputPanel(void * jarg1, unsigned int jarg2) {
94227   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94228   bool arg2 ;
94229
94230   arg1 = (Dali::ImfManager *)jarg1;
94231   arg2 = jarg2 ? true : false;
94232   {
94233     try {
94234       (arg1)->AutoEnableInputPanel(arg2);
94235     } catch (std::out_of_range& e) {
94236       {
94237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94238       };
94239     } catch (std::exception& e) {
94240       {
94241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94242       };
94243     } catch (...) {
94244       {
94245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94246       };
94247     }
94248   }
94249 }
94250
94251
94252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_ShowInputPanel(void * jarg1) {
94253   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94254
94255   arg1 = (Dali::ImfManager *)jarg1;
94256   {
94257     try {
94258       (arg1)->ShowInputPanel();
94259     } catch (std::out_of_range& e) {
94260       {
94261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94262       };
94263     } catch (std::exception& e) {
94264       {
94265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94266       };
94267     } catch (...) {
94268       {
94269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94270       };
94271     }
94272   }
94273 }
94274
94275
94276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImfManager_HideInputPanel(void * jarg1) {
94277   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94278
94279   arg1 = (Dali::ImfManager *)jarg1;
94280   {
94281     try {
94282       (arg1)->HideInputPanel();
94283     } catch (std::out_of_range& e) {
94284       {
94285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94286       };
94287     } catch (std::exception& e) {
94288       {
94289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94290       };
94291     } catch (...) {
94292       {
94293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94294       };
94295     }
94296   }
94297 }
94298
94299
94300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ActivatedSignal(void * jarg1) {
94301   void * jresult ;
94302   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94303   Dali::ImfManager::ImfManagerSignalType *result = 0 ;
94304
94305   arg1 = (Dali::ImfManager *)jarg1;
94306   {
94307     try {
94308       result = (Dali::ImfManager::ImfManagerSignalType *) &(arg1)->ActivatedSignal();
94309     } catch (std::out_of_range& e) {
94310       {
94311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94312       };
94313     } catch (std::exception& e) {
94314       {
94315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94316       };
94317     } catch (...) {
94318       {
94319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94320       };
94321     }
94322   }
94323   jresult = (void *)result;
94324   return jresult;
94325 }
94326
94327
94328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_EventReceivedSignal(void * jarg1) {
94329   void * jresult ;
94330   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94331   Dali::ImfManager::ImfEventSignalType *result = 0 ;
94332
94333   arg1 = (Dali::ImfManager *)jarg1;
94334   {
94335     try {
94336       result = (Dali::ImfManager::ImfEventSignalType *) &(arg1)->EventReceivedSignal();
94337     } catch (std::out_of_range& e) {
94338       {
94339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94340       };
94341     } catch (std::exception& e) {
94342       {
94343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94344       };
94345     } catch (...) {
94346       {
94347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94348       };
94349     }
94350   }
94351   jresult = (void *)result;
94352   return jresult;
94353 }
94354
94355
94356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_StatusChangedSignal(void * jarg1) {
94357   void * jresult ;
94358   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94359   Dali::ImfManager::StatusSignalType *result = 0 ;
94360
94361   arg1 = (Dali::ImfManager *)jarg1;
94362   {
94363     try {
94364       result = (Dali::ImfManager::StatusSignalType *) &(arg1)->StatusChangedSignal();
94365     } catch (std::out_of_range& e) {
94366       {
94367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94368       };
94369     } catch (std::exception& e) {
94370       {
94371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94372       };
94373     } catch (...) {
94374       {
94375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94376       };
94377     }
94378   }
94379   jresult = (void *)result;
94380   return jresult;
94381 }
94382
94383
94384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_ResizedSignal(void * jarg1) {
94385   void * jresult ;
94386   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94387   Dali::ImfManager::VoidSignalType *result = 0 ;
94388
94389   arg1 = (Dali::ImfManager *)jarg1;
94390   {
94391     try {
94392       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->ResizedSignal();
94393     } catch (std::out_of_range& e) {
94394       {
94395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94396       };
94397     } catch (std::exception& e) {
94398       {
94399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94400       };
94401     } catch (...) {
94402       {
94403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94404       };
94405     }
94406   }
94407   jresult = (void *)result;
94408   return jresult;
94409 }
94410
94411
94412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImfManager_LanguageChangedSignal(void * jarg1) {
94413   void * jresult ;
94414   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94415   Dali::ImfManager::VoidSignalType *result = 0 ;
94416
94417   arg1 = (Dali::ImfManager *)jarg1;
94418   {
94419     try {
94420       result = (Dali::ImfManager::VoidSignalType *) &(arg1)->LanguageChangedSignal();
94421     } catch (std::out_of_range& e) {
94422       {
94423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94424       };
94425     } catch (std::exception& e) {
94426       {
94427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94428       };
94429     } catch (...) {
94430       {
94431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94432       };
94433     }
94434   }
94435   jresult = (void *)result;
94436   return jresult;
94437 }
94438
94439
94440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_0() {
94441   void * jresult ;
94442   Dali::ImfManager *result = 0 ;
94443
94444   {
94445     try {
94446       result = (Dali::ImfManager *)new Dali::ImfManager();
94447     } catch (std::out_of_range& e) {
94448       {
94449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94450       };
94451     } catch (std::exception& e) {
94452       {
94453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94454       };
94455     } catch (...) {
94456       {
94457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94458       };
94459     }
94460   }
94461   jresult = (void *)result;
94462   return jresult;
94463 }
94464
94465
94466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImfManager(void * jarg1) {
94467   Dali::ImfManager *arg1 = (Dali::ImfManager *) 0 ;
94468
94469   arg1 = (Dali::ImfManager *)jarg1;
94470   {
94471     try {
94472       delete arg1;
94473     } catch (std::out_of_range& e) {
94474       {
94475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94476       };
94477     } catch (std::exception& e) {
94478       {
94479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94480       };
94481     } catch (...) {
94482       {
94483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94484       };
94485     }
94486   }
94487 }
94488
94489
94490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImfManager__SWIG_1(void * jarg1) {
94491   void * jresult ;
94492   Dali::Internal::Adaptor::ImfManager *arg1 = (Dali::Internal::Adaptor::ImfManager *) 0 ;
94493   Dali::ImfManager *result = 0 ;
94494
94495   arg1 = (Dali::Internal::Adaptor::ImfManager *)jarg1;
94496   {
94497     try {
94498       result = (Dali::ImfManager *)new Dali::ImfManager(arg1);
94499     } catch (std::out_of_range& e) {
94500       {
94501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94502       };
94503     } catch (std::exception& e) {
94504       {
94505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94506       };
94507     } catch (...) {
94508       {
94509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94510       };
94511     }
94512   }
94513   jresult = (void *)result;
94514   return jresult;
94515 }
94516
94517
94518 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ImfManager_SWIGUpcast(Dali::ImfManager *jarg1) {
94519     return (Dali::BaseHandle *)jarg1;
94520 }
94521
94522
94523 //////////////////////////////////////////////////
94524 //from dali-swig autogeneration (from dali_wrap.cpp)
94525
94526
94527
94528
94529
94530
94531
94532
94533
94534
94535
94536
94537 #ifdef __cplusplus
94538 }
94539 #endif
94540